@thierrynakoa/fire-flow 12.2.1 → 13.0.1

package/skills-library/marketing/social-media-analyzer.md

@@ -0,0 +1,81 @@
+# Social Media Analyzer
+
+## Triggers
+Use when: social media performance, engagement rate, campaign analytics, Instagram metrics, LinkedIn analytics, TikTok performance, social ROI
+
+---
+
+## Core Metrics
+
+**Engagement Rate formula:**
+```
+ER = (Likes + Comments + Shares + Saves) / Reach × 100
+```
+
+**Platform benchmarks:**
+
+| Platform | Average ER | Good | Excellent |
+|----------|-----------|------|-----------|
+| Instagram | 1.22% | 3–6% | >6% |
+| Facebook | 0.07% | 0.5–1% | >1% |
+| Twitter/X | 0.05% | 0.1–0.5% | >0.5% |
+| LinkedIn | 2.0% | 3–5% | >5% |
+| TikTok | 5.96% | 8–15% | >15% |
+
+---
+
+## ROI Metrics
+
+```
+CPE (Cost Per Engagement) = Total Spend / Total Engagements
+CPC (Cost Per Click)      = Total Spend / Total Clicks
+ROI                       = (Value Generated - Spend) / Spend × 100
+```
+
+**Engagement value estimates (baseline):**
+| Action | Estimated Value |
+|--------|----------------|
+| Like | $0.50 |
+| Comment | $2.00 |
+| Share | $5.00 |
+| Save | $3.00 |
+| Click | $1.50 |
+
+---
+
+## Analysis Workflow
+
+1. **Collect data:** Pull last 30/60/90 days from platform analytics
+2. **Calculate ER:** Per post and average for the period
+3. **Identify top performers:** Top 20% of posts by ER
+4. **Pattern analysis:** What do top posts have in common? (format, topic, length, time)
+5. **Benchmark:** Compare against platform averages above
+6. **Recommendations:** Double down on what works, cut what underperforms
+
+---
+
+## Content Performance Scoring
+
+Score each post across:
+- **Reach score:** Impressions vs. follower count ratio
+- **Engagement score:** ER vs. platform benchmark
+- **Conversion score:** Clicks or link taps (if trackable)
+- **Save rate:** Saves / Reach (high saves = high-value content)
+
+**Winning post signals:**
+- ER 2× platform average
+- Save rate >2%
+- Comments with questions (signals community interest)
+- Shares (signals shareworthy insight)
+
+---
+
+## Posting Strategy
+
+| Platform | Optimal Frequency | Best Times (general) |
+|----------|------------------|---------------------|
+| LinkedIn | 3–5x/week | Tue–Thu, 8–10am |
+| Instagram | 4–7x/week | Mon/Wed/Fri, 11am–1pm |
+| Twitter/X | 1–5x/day | Weekdays, 9am & 5pm |
+| Facebook | 1–2x/day | Wed, 11am–1pm |
+| TikTok | 1–4x/day | Tue/Thu/Fri, 7–9pm |

package/skills-library/methodology/ADVANCED_ORCHESTRATION_PATTERNS.md

@@ -0,0 +1,401 @@
+# Advanced Orchestration Patterns
+
+**Version:** 1.0
+**Date:** January 2026
+**Status:** INTEGRATED from Dominion Flow + RALPH WIGGUM + N8N PATTERNS
+
+A synthesis of best practices from Dominion Flow (Dominion Flow), Ralph Wiggum loops, and n8n workflow patterns for advanced AI agent orchestration.
+
+---
+
+## Executive Summary
+
+Three powerful patterns for AI-assisted development:
+
+1. **State Management** (from Dominion Flow) - Living memory files that enable session continuity
+2. **Self-Iterating Loops** (from Ralph Wiggum) - Autonomous iteration with completion promises
+3. **Breath-Based Parallel Execution** (from Dominion Flow) - Maximize throughput with dependency-aware parallelism
+
+**Key Insight:** When AI generates code instantly, **feedback mechanisms become the true bottleneck**. These patterns compress feedback loops and enable rapid generate-test-iterate cycles.
+
+---
+
+## Pattern 1: State Management (Living Memory)
+
+### The Problem
+
+Information is captured in summaries, issues, and decisions but not systematically consumed. Sessions start without context. Context is lost across sessions.
+
+### The Solution: CONSCIENCE.md
+
+A single, small file (<100 lines) that's:
+- Read first in every workflow
+- Updated after every significant action
+- Contains digest of accumulated context
+- Enables instant session restoration
+
+### Template
+
+```markdown
+# Project State
+
+## Project Reference
+
+See: .planning/PROJECT.md (updated [date])
+
+**Core value:** [One-liner describing the ONE thing that matters]
+**Current focus:** [Current phase name]
+
+## Current Position
+
+Phase: [X] of [Y] ([Phase name])
+Plan: [A] of [B] in current phase
+Status: [Ready to plan / Planning / Ready to execute / In progress / Phase complete]
+Last activity: [YYYY-MM-DD] — [What happened]
+
+Progress: [░░░░░░░░░░] 0%
+
+## Performance Metrics
+
+**Velocity:**
+- Total plans completed: [N]
+- Average duration: [X] min
+- Total execution time: [X.X] hours
+
+**Recent Trend:**
+- Last 5 plans: [durations]
+- Trend: [Improving / Stable / Degrading]
+
+## Accumulated Context
+
+### Decisions
+- [Phase X]: [Decision summary]
+- [Phase Y]: [Decision summary]
+
+### Pending Todos
+[From pending todos - ideas captured during sessions]
+
+### Blockers/Concerns
+[Issues that affect future work]
+
+## Session Continuity
+
+Last session: [YYYY-MM-DD HH:MM]
+Stopped at: [Description of last completed action]
+Resume file: [Path to continue-here file if exists]
+```
+
+### Lifecycle
+
+| Event | Action |
+|-------|--------|
+| Project Init | Create CONSCIENCE.md after roadmap |
+| Every Workflow Start | Read CONSCIENCE.md first |
+| After Each Plan | Update position, note decisions |
+| Phase Transition | Update progress bar, clear resolved blockers |
+
+### Size Constraint
+
+**Keep under 100 lines.** It's a DIGEST, not an archive. If it's too long, "read once, know where we are" fails.
+
+---
+
+## Pattern 2: Self-Iterating Loops (Ralph Wiggum)
+
+### The Concept
+
+Run the AI agent on the same prompt repeatedly until a stop condition is met. The prompt never changes, but the world does:
+- Previous work persisted in files
+- Git history of what changed
+- Test results, build output, error messages
+- Any other artifacts from the last run
+
+### Basic Structure
+
+```bash
+/ralph-loop "Build X with tests. Output DONE when all tests pass." \
+  --completion-promise "DONE" \
+  --max-iterations 50
+```
+
+### When to Use
+
+| Good For | Bad For |
+|----------|---------|
+| Getting test suites to pass | Tasks requiring human judgment |
+| Fixing all linter/type errors | Unclear success criteria |
+| Building features with clear acceptance criteria | Production debugging |
+| Greenfield projects with defined "done" | One-shot operations |
+
+### Key Principles
+
+**1. Completion Promise**
+Define success criteria upfront. "Make it better" doesn't work. "All tests pass" does.
+
+**2. Threshold-Based Stopping**
+Stop when:
+- Self-rating hits target (e.g., 9/10)
+- Max iterations reached
+- Completion promise detected in output
+
+**3. Regression Detection**
+Progress isn't linear. The loop must recognize when it went astray and course-correct.
+
+**4. Specific Self-Critique**
+Concrete questions drive improvement:
+- Is the test passing now?
+- Is there symmetry/consistency?
+- Does the structure meet requirements?
+- Are edge cases handled?
+
+### Implementation for WARRIOR
+
+```markdown
+## Self-Iteration Checklist
+
+Before starting a loop:
+- [ ] Define clear success criteria
+- [ ] Set max iteration limit
+- [ ] Identify what artifacts to check
+- [ ] Establish baseline (current state)
+
+During iteration:
+- [ ] Compare against baseline
+- [ ] Log what changed
+- [ ] Rate progress (1-10)
+- [ ] Identify specific improvements needed
+
+Stop when:
+- [ ] Success criteria met
+- [ ] Max iterations reached
+- [ ] No meaningful progress for 3 iterations
+```
+
+---
+
+## Pattern 3: Breath-Based Parallel Execution
+
+### The Concept
+
+Group independent tasks into breaths. Execute tasks within a breath in parallel. Wait for breath completion before starting the next breath.
+
+### Why It Works
+
+- **Orchestrator context usage:** ~10-15%
+- **Each subagent:** Fresh 200k context
+- **No polling:** Task tool blocks until completion
+- **No context bleed:** Orchestrator never reads workflow internals
+
+### Breath Assignment
+
+```yaml
+# Breath 1: No dependencies, can run in parallel
+Plan 01:
+  breath: 1
+  depends_on: []
+  files_modified: [src/features/user/]
+  autonomous: true
+
+Plan 02:
+  breath: 1
+  depends_on: []
+  files_modified: [src/features/product/]
+  autonomous: true
+
+# Breath 2: Depends on Breath 1
+Plan 03:
+  breath: 2
+  depends_on: ["01", "02"]
+  files_modified: [src/features/dashboard/]
+  autonomous: false  # Has checkpoint
+```
+
+### Execution Flow
+
+```
+Breath 1: [Plan 01] [Plan 02] [Plan 03]  ← Parallel
+           ↓         ↓         ↓
+        Complete  Complete  Complete
+                    ↓
+Breath 2: [Plan 04] [Plan 05]            ← Parallel
+           ↓         ↓
+        Complete  Checkpoint → User Input → Resume
+                    ↓
+Breath 3: [Plan 06]                      ← Sequential
+           ↓
+        Complete + Verify
+```
+
+### Checkpoint Types
+
+| Type | Use For | Behavior |
+|------|---------|----------|
+| `auto` | Everything Claude can do | Fully autonomous |
+| `checkpoint:human-verify` | Visual/functional verification | Pauses, returns to user |
+| `checkpoint:decision` | Implementation choices | Presents options to user |
+| `checkpoint:human-action` | Unavoidable manual steps | Pauses for human action |
+
+### Failure Handling
+
+| Scenario | Response |
+|----------|----------|
+| Subagent fails mid-plan | RECORD.md won't exist, detect and report |
+| Dependency chain breaks | Ask user: continue or stop? |
+| All agents in breath fail | Stop, report for investigation |
+| Checkpoint won't resolve | Skip plan or abort execution |
+
+---
+
+## Pattern 4: Goal-Backward Verification
+
+### The Problem
+
+Task completion ≠ Goal achievement. A task "create chat component" can complete by creating a placeholder.
+
+### The Solution: Must-Haves
+
+Define what must be TRUE for the goal to be achieved:
+
+```yaml
+must_haves:
+  truths:                    # Observable behaviors
+    - "User can see existing messages"
+    - "User can send a message"
+    - "Messages persist across refresh"
+
+  artifacts:                 # Files that must exist
+    - path: "src/components/Chat.tsx"
+      provides: "Message list rendering"
+      min_lines: 30
+    - path: "src/app/api/chat/route.ts"
+      exports: ["GET", "POST"]
+
+  key_links:                 # Connections between artifacts
+    - from: "src/components/Chat.tsx"
+      to: "/api/chat"
+      pattern: "fetch.*api/chat"
+```
+
+### Verification Flow
+
+1. Plan-phase derives must_haves from phase goal
+2. Execute-phase runs all plans
+3. Verification subagent checks must_haves against codebase
+4. Gaps found → fix plans created → execute → re-verify
+5. All must_haves pass → phase complete
+
+---
+
+## Pattern 5: Context Efficiency
+
+### Orchestrator vs Subagent Roles
+
+| Orchestrator (Lean) | Subagent (Full Context) |
+|---------------------|------------------------|
+| Read plan frontmatter | Load full workflow |
+| Analyze dependencies | Load templates, references |
+| Fill template strings | Execute plan with full capacity |
+| Spawn Task calls | Create artifacts, commits |
+| Collect results | Return structured output |
+
+### Anti-Patterns
+
+- Orchestrator reading full workflow files
+- Subagent loading unnecessary context
+- Polling for completion (use blocking Task)
+- Reflexive dependency chaining
+
+### Prompt Templates
+
+**Subagent Task Prompt:**
+```markdown
+<objective>
+Execute plan {plan_number} of phase {phase_number}-{phase_name}.
+Commit each task atomically. Create RECORD.md. Update CONSCIENCE.md.
+</objective>
+
+<execution_context>
+@~/.claude/plugins/dominion-flow/workflows/execute-plan.md
+@~/.claude/plugins/dominion-flow/templates/summary.md
+</execution_context>
+
+<context>
+Plan: @{plan_path}
+Project state: @.planning/CONSCIENCE.md
+</context>
+
+<success_criteria>
+- [ ] All tasks executed
+- [ ] Each task committed individually
+- [ ] RECORD.md created
+- [ ] CONSCIENCE.md updated
+</success_criteria>
+```
+
+---
+
+## Integration with WARRIOR Workflow
+
+### Session Start Protocol
+
+1. Read CONSCIENCE.md (if exists) for project context
+2. Check WARRIOR handoffs for session continuity
+3. Present current position to user
+4. Identify next action based on status
+
+### During Execution
+
+1. Use breath-based execution for multi-task phases
+2. Apply self-iteration for tasks needing refinement
+3. Create checkpoints for human verification
+4. Update CONSCIENCE.md after each significant action
+
+### Session End Protocol
+
+1. Update CONSCIENCE.md with final position
+2. Create WARRIOR handoff if context exhaustion approaching
+3. Log performance metrics
+4. Note any blockers for next session
+
+---
+
+## Quick Reference
+
+### Commands Pattern (Dominion-Style)
+
+| Command | Purpose |
+|---------|---------|
+| `/warrior:status` | Show current CONSCIENCE.md |
+| `/warrior:execute` | Run breath-based execution |
+| `/warrior:verify` | Run goal-backward verification |
+| `/warrior:iterate` | Start self-improvement loop |
+
+### Velocity Metrics
+
+Track these to understand execution patterns:
+- Plans completed per session
+- Average duration per plan
+- Regression count (iterations that got worse)
+- Checkpoint approval rate
+
+### Success Indicators
+
+- CONSCIENCE.md under 100 lines
+- <15% orchestrator context usage
+- Completion within max iterations
+- All must_haves verified
+
+---
+
+## Sources
+
+- **Dominion Flow:** [glittercowboy/get-shit-done](https://github.com/glittercowboy/get-shit-done)
+- **Ralph Wiggum:** [UtpalJayNadiger/ralphwiggumexperiment](https://github.com/UtpalJayNadiger/ralphwiggumexperiment)
+- **n8n-MCP:** [czlonkowski/n8n-mcp](https://github.com/czlonkowski/n8n-mcp)
+- **n8n-skills:** [czlonkowski/n8n-skills](https://github.com/czlonkowski/n8n-skills)
+
+---
+
+**Created:** January 2026
+**For:** WARRIOR Workflow Integration
+**License:** MIT

package/skills-library/methodology/AGENT_SELF_IMPROVEMENT_LOOP.md

@@ -0,0 +1,179 @@
+# Agent Self-Improvement Loop — 6-Upgrade Blueprint for Cross-Session Learning
+
+## The Problem
+
+AI agent systems (like Dominion Flow) can accumulate skills and memory, but they don't systematically **learn from their own failures**. Agents make the same mistakes across sessions, don't self-evaluate before acting, and can't adapt their autonomy based on experience. The system captures knowledge but doesn't close the loop.
+
+### Why It Was Hard
+
+- Agent memory systems typically store *what happened*, not *what went wrong and why*
+- Self-evaluation adds latency — finding the right balance between thoroughness and speed
+- Auto-extracting reusable patterns requires distinguishing project-specific code from generalizable solutions
+- Confidence estimation is subjective and easy to game (agent always says "high confidence")
+- The 6 capabilities interact — reflection feeds confidence, confidence gates execution, execution produces reflections
+
+### Impact
+
+- Same debugging mistakes repeated session after session
+- No systematic recovery from failures (73.5% recovery → 95% with self-evaluation)
+- Skills library grows only through manual contribution (capture gap)
+- Agent can't distinguish "I know this" from "I'm guessing" — treats all tasks equally
+
+---
+
+## The Solution
+
+### Root Cause
+
+The gap is not in missing systems but in **missing feedback loops**. Most agent frameworks are open-loop: plan → execute → done. Research shows closed-loop agents (plan → execute → reflect → learn → plan better) dramatically outperform open-loop ones.
+
+### The 6-Upgrade Blueprint
+
+Apply these 6 upgrades in order (each builds on the previous):
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  1. REFLECTION MEMORY        (capture failures)          │
+│  2. PRE-ACTION SELF-JUDGE    (catch mistakes early)      │
+│  3. EXPERIENCE REPLAY        (index resolved debugs)     │
+│  4. SKILL AUTO-EXTRACTION    (learn from success)        │
+│  5. AUTO-CONSOLIDATION       (keep memory fresh)         │
+│  6. CONFIDENCE GATES         (adapt behavior to certainty)│
+└──────────────────────────────────────────────────────────┘
+
+Feedback loop:
+  Execute → Self-Judge → Reflect on failures →
+  Index for replay → Extract skills from success →
+  Consolidate memory → Estimate confidence → Execute better
+```
+
+### Upgrade 1: Reflection Memory
+**Research:** Reflexion (NeurIPS 2023) — 91% pass@1
+
+Store "what I tried and why it failed" as searchable reflections. Before investigating any issue, search past reflections first.
+
+```
+Location: ~/.claude/reflections/{date}_{slug}.md
+Format: Problem → Failed approaches → What worked → Lesson → Search triggers
+Trigger: After debug resolution, test failure, approach rotation
+Search: Before new debug sessions and complex tasks
+```
+
+### Upgrade 2: Pre-Action Self-Judge
+**Research:** Agent-as-Judge (2025) — 95% error recovery
+
+5-point gut check before marking any task complete:
+1. Does this do what the plan asked?
+2. Could this break something working?
+3. Am I confident or guessing?
+4. Did I check obvious things (imports, types, null)?
+5. Would I approve this in code review?
+
+If any "no" or "uncertain" → stop and re-examine.
+
+### Upgrade 3: Experience Replay
+**Research:** ECHO (2025) — 80% improvement
+
+Index resolved debug sessions into vector memory. Future debug sessions search for similar symptoms and shortcut investigation by applying known root causes.
+
+```
+Resolved debug file → Index in Qdrant as 'debug_resolution'
+Future debug → Search: /fire-remember "{symptoms}" --type debug_resolution
+If match found → "I've seen this before. Root cause was X. Fix was Y."
+```
+
+### Upgrade 4: Auto Skill Extraction
+**Research:** SAGE (2025) — 8.9% higher completion, 26% fewer steps
+
+After successful verification, scan execution for extractable patterns:
+- Generalizable (not project-specific)
+- Non-trivial (>3 files or >30 min work)
+- Required research or multiple attempts
+
+Auto-extracted → quarantine → human review → approve or reject.
+
+### Upgrade 5: Auto-Consolidation
+**Research:** Mem0 (2025) — 91% lower latency
+
+Make memory refresh automatic:
+- Index all memory dirs recursively (including skills library)
+- Extract facts from handoffs
+- Run on session end or manually
+
+### Upgrade 6: Confidence-Gated Actions
+**Research:** SAUP (ACL 2025) — uncertainty propagation
+
+Score confidence before each action:
+- HIGH (>80%): Proceed autonomously
+- MEDIUM (50-80%): Extra validation, search reflections
+- LOW (<50%): Pause, escalate, ask for help
+
+Signals: +skill match, +tests available, +familiar tech, -unfamiliar framework, -no tests, -ambiguous requirements.
+
+---
+
+## Testing the Fix
+
+### Verification Criteria
+
+1. **Reflection Memory:** Create a test reflection → search via vector memory → confirm it returns
+2. **Self-Judge:** Execute a task → confirm 5-point check runs → "uncertain" creates reflection
+3. **Debug Replay:** Resolve a debug → index → search symptoms → confirm resolution surfaces
+4. **Skill Extraction:** Complete phase with novel pattern → quarantine candidate generated
+5. **Auto-Consolidation:** Run consolidate → verify new files indexed, skills searchable
+6. **Confidence Gates:** Execute varying-familiarity tasks → HIGH proceeds, LOW pauses
+
+---
+
+## Prevention
+
+- Wire reflections into debug flow as mandatory step (not optional)
+- Self-Judge is 30 seconds — fast enough to never skip
+- Auto-consolidation runs on session end (no manual trigger needed)
+- Confidence gates are advisory, not blocking (agent can override with justification)
+
+---
+
+## Related Patterns
+
+- [REFLEXION_MEMORY_PATTERN](./REFLEXION_MEMORY_PATTERN.md) - Detailed reflection implementation
+- [CONFIDENCE_GATED_EXECUTION](./CONFIDENCE_GATED_EXECUTION.md) - Detailed confidence scoring
+- [EVOLUTIONARY_SKILL_SYNTHESIS](./EVOLUTIONARY_SKILL_SYNTHESIS.md) - Skill auto-extraction details
+- [SELF_QUESTIONING_TASK_GENERATION](./SELF_QUESTIONING_TASK_GENERATION.md) - Full self-evaluation framework
+
+---
+
+## Common Mistakes to Avoid
+
+- Treating reflection as optional ("I'll write it later" = never)
+- Making Self-Judge a 70-point checklist (5 points max — speed is critical)
+- Extracting project-specific code as "general" skills (quarantine catches this)
+- Confidence score = 100% always (agents tend to be overconfident — calibrate)
+- Running full consolidation on every session end (use light mode — index only)
+- Skipping pre-investigation reflection search ("I already know this" = confirmation bias)
+
+---
+
+## Resources
+
+- Reflexion (NeurIPS 2023): https://arxiv.org/abs/2303.11366
+- SAGE (Dec 2025): https://arxiv.org/abs/2512.17102
+- ECHO (2025): Experience replay for agents
+- Agent-as-Judge (2025): Self-evaluation patterns
+- SAUP (ACL 2025): Uncertainty propagation
+- Mem0 (2025): Auto-consolidation architecture
+
+---
+
+## Time to Implement
+
+**10-14 hours** across all 6 upgrades. Can be done incrementally — each upgrade is independently valuable.
+
+## Difficulty Level
+
+Stars: 4/5 — Individual upgrades are straightforward. The challenge is **wiring them together** so they form a coherent feedback loop rather than isolated features.
+
+---
+
+**Author Notes:**
+The key research finding that motivated this: **recovery ability, not error avoidance, differentiates top agents** (95% vs 73.5% recovery rate). This means making agents "smarter" isn't about preventing mistakes — it's about learning from them systematically. The 6-upgrade loop closes this gap by making failure data persistent, searchable, and actionable across sessions.

package/skills-library/methodology/BREATH_BASED_PARALLEL_EXECUTION.md

@@ -530,7 +530,7 @@ await executeWave(3, wave3Plans);
 ## Resources
 
 ### Dominion Flow Documentation
-- Dominion Flow Plugin: `~/.claude/plugins/fire-flow/`
+- Dominion Flow Plugin: `~/.claude/plugins/dominion-flow/`
 - Execution Command: `/fire-3-execute N`
 - Agent Definitions: `@agents/fire-executor.md`