kodelyth-ecc 1.7.1 → 1.7.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.7.2 — Final platform count clean-up (May 2026)
+
+- Fix two remaining `12 platforms` references in `wiki/FAQ.md` and `wiki/Home.md`
+- Sync `VERSION` file to match `package.json`
+- Update `wiki/Home.md` version badge to v1.7.1 → v1.7.2
+
+---
+
 ## v1.7.1 — Platform count correction + SVG glow fix (May 2026)
 
 Accuracy patch: all docs, social assets, and the wiki now consistently reflect the correct

package/MARKETING_PLAN.md

@@ -0,0 +1,893 @@
+# Kodelyth ECC v1.7.0 — Full Marketing Plan
+
+> Version: 1.7.0 · MCP Server launch + dashboard hardening + 336 tests  
+> Goal: Maximum visibility across developer communities — GitHub stars, npm downloads, community adoption  
+> Tone: Technical credibility + bold confidence. Never hype. Let the numbers speak.
+
+---
+
+## AUDIT SUMMARY (what we're selling)
+
+| Asset | Count |
+|---|---|
+| Agents | **70** (incl. 8 devil-mode adversarial) |
+| Skills | **194** |
+| Commands | **97** (8 parallel multi-agent) |
+| Hooks | **22+** |
+| Platforms | **11** (13 install targets) |
+| Tests | **336** |
+| MCP tools | **16** |
+| MCP resources | **377** |
+| Bundles | **3** (indie-hacker, red-team, enterprise) |
+| Install | `npx kodelyth-ecc` |
+
+**Key differentiators to hammer:**
+1. Intent routing — plain language, no memorizing names
+2. Local compound memory — BM25, zero deps, zero cloud
+3. Devil mode — 8 adversarial agents, attacker mindset
+4. MCP server — universal adapter, any framework
+5. Parallel agents — 8 commands, minutes not hours
+6. Zero telemetry — fully verifiable, fully yours
+
+---
+
+## PHASE 1 — GitHub Visibility (Week 1-2)
+
+### 1.1 GitHub Repository Optimization
+
+**README badges to add/verify:**
+- All platform badges already present ✅
+- Add: `[![npm downloads](https://img.shields.io/npm/dm/kodelyth-ecc.svg)](https://www.npmjs.com/package/kodelyth-ecc)`
+- Add: `[![npm version](https://img.shields.io/npm/v/kodelyth-ecc.svg)](https://www.npmjs.com/package/kodelyth-ecc)`
+- Add: `[![GitHub stars](https://img.shields.io/github/stars/sifxprime/kodelyth-ecc)](https://github.com/sifxprime/kodelyth-ecc/stargazers)`
+- Add: `[![Tests](https://img.shields.io/badge/tests-336%20passing-brightgreen)]`
+
+**GitHub About section (right sidebar):**
+```
+70 agents · 194 skills · 97 commands · MCP server · devil mode · 11 platforms · zero telemetry
+```
+Topics to add: `claude-code` `windsurf` `cursor` `ai-agents` `llm` `mcp` `model-context-protocol` `developer-tools` `coding-toolkit` `devil-mode` `red-team` `local-memory` `self-learning` `intent-routing` `parallel-agents`
+
+**Social preview:** Already created `social/github-social-preview.svg` — upload to GitHub Settings → Social preview
+
+**Wiki:** 7 pages already written — make sure all are published on GitHub Wiki (not just in repo).
+
+### 1.2 GitHub Discussions Setup
+
+Create these discussion categories:
+- **Show & Tell** — "What did you use ECC for this week?"
+- **Ideas** — feature requests  
+- **Q&A** — support
+- **Devil Mode Stories** — security finds, red-team results
+
+**Pinned discussion to create:**
+> **Welcome to Kodelyth ECC! Start here.**
+> One post that links to quickstart, bundles, wiki, and asks people to share their first result.
+
+### 1.3 GitHub Issues — Good First Issues
+
+Create 5-10 issues tagged `good first issue`:
+- "Add new language-specific reviewer: Ruby"
+- "Add Haskell rules to rules/languages/"
+- "Improve onboarding docs for Aider target"
+- "Add a new devil-mode agent: rate-limit-tester"
+- "Write CONTRIBUTING template for new skill"
+
+These drive organic contributor traffic.
+
+---
+
+## PHASE 2 — Product Hunt Launch (Week 2)
+
+### 2.1 Product Hunt Post
+
+**Name:** Kodelyth ECC  
+**Tagline:** `70 AI coding agents. One install. Zero cloud.`  
+**Description (short):**
+> The most production-grade AI coding toolkit available. 70 specialist agents with intent routing — describe your problem in plain English and the right expert fires automatically. Ships with 8 adversarial devil-mode agents, local self-learning memory, MCP server, parallel multi-agent commands, and a live localhost dashboard. Works across 11 IDEs. `npx kodelyth-ecc` is all you need.
+
+**Gallery images to prepare (use social/ SVGs):**
+1. `github-social-preview.svg` — hero
+2. `x-card-agents-grid.svg` — agents grid
+3. `facebook-v150.svg` — feature breakdown
+4. Screenshot of dashboard (real screen capture)
+5. Terminal gif: `npx kodelyth-ecc` installing, then a routing demo
+
+**Product Hunt launch day checklist:**
+- [ ] Post at 12:01 AM PST (Tuesday or Wednesday — peak day)
+- [ ] First comment from maker: personal story of why you built it
+- [ ] Share in 5+ Slack/Discord communities that day
+- [ ] Post on X with `#ProductHunt` the moment it goes live
+- [ ] Ask your network to upvote (not just star, upvote with genuine comment)
+
+**Maker comment template:**
+```
+I built Kodelyth ECC because I was tired of remembering agent names.
+
+Every "AI toolkit" I tried was just a folder of markdown files.
+You had to know the agent existed before you could use it.
+
+ECC flips this: describe your problem in plain English →
+the right specialist fires automatically → you learn its name for next time.
+
+70 agents. Intent routing. Local memory that compounds over time.
+No cloud. No telemetry. Everything on your disk, verifiable.
+
+Happy to answer anything — especially questions about devil mode 😈
+```
+
+---
+
+## PHASE 3 — X / Twitter Campaign (Weeks 1-4)
+
+### Thread 1 — The Hook Thread (Day 1, Launch Day)
+
+**Tweet 1 (hook):**
+```
+I built an AI coding toolkit with 70 specialist agents.
+
+You don't need to remember their names.
+
+Just describe your problem. The right expert fires.
+
+Thread 🧵
+```
+
+**Tweet 2:**
+```
+Most "AI agent kits" = a folder of markdown files.
+
+You memorize names. You remember syntax. You context-switch.
+
+Kodelyth ECC is different.
+
+It reads your intent and routes you silently.
+
+"I've been staring at this bug for 2 hours"
+→ routes to debug-detective automatically
+```
+
+**Tweet 3:**
+```
+The 10-tier intent routing priority:
+
+1. Confusion/overwhelm → kodelyth-advisor
+2. Active bug → debug-detective
+3. Code review → code-reviewer
+4. Security → security-reviewer
+5. Performance → performance-optimizer
+...and 5 more
+
+No slash command. Just plain English.
+```
+
+**Tweet 4:**
+```
+Devil Mode.
+
+8 adversarial agents that read your code like an attacker:
+
+• prompt-injection-hunter
+• supply-chain-auditor
+• secret-hunter
+• backdoor-hunter
+• jailbreak-tester
+• license-violation-finder
+• code-stealer-detector
+• chaos-engineer
+
+/devil-mode --pre-public before you go open source.
+```
+
+**Tweet 5:**
+```
+The compound memory is the part I'm most proud of.
+
+Session 1: you debug a Stripe webhook issue
+Session 2 (5 months later, new project): you mention Stripe webhooks
+→ AI recalls your exact fix before you even ask
+
+BM25. Local. Zero cloud. Zero deps.
+```
+
+**Tweet 6:**
+```
+Parallel agents save hours.
+
+/team-review  → 4 agents in parallel: 60 min → 15 min
+/project-launch → 5 founding-team agents: 45 min → 10 min
+/debug-blitz → 3 debug agents on a stubborn bug
+/devil-mode --all → 8 adversarial agents simultaneously
+
+Not sequential. Actually parallel.
+```
+
+**Tweet 7:**
+```
+MCP server is new in v1.7.0.
+
+npx kodelyth-ecc mcp
+
+→ 16 tools
+→ 6 prompts
+→ 377 resources (every agent, skill, command)
+
+Works with Claude Desktop, LangGraph, AutoGen, CrewAI,
+OpenAI Agents SDK, Cursor, Windsurf.
+
+One command. Any framework.
+```
+
+**Tweet 8 (social proof + CTA):**
+```
+11 platforms. 13 install targets.
+70 agents. 194 skills. 97 commands.
+336 tests. Zero telemetry.
+
+One command:
+npx kodelyth-ecc
+
+github.com/sifxprime/kodelyth-ecc
+
+If this helped you, RT the first tweet. 🙏
+```
+
+---
+
+### Thread 2 — Devil Mode Deep Dive (Week 2)
+
+```
+Most developers ship code without ever asking:
+"What would an attacker find here?"
+
+Kodelyth devil mode asks for you.
+
+8 adversarial agents. In parallel. Here's what each one hunts 🧵
+```
+
+- Tweet for each of the 8 agents with what it hunts + real example bash pattern
+- End with: `/devil-mode --pre-public` before any open-source release
+
+---
+
+### Thread 3 — Memory System Deep Dive (Week 2)
+
+```
+AI has no memory.
+
+But YOUR AI does — if you use Kodelyth ECC.
+
+Here's how compound memory works and why it changes everything 🧵
+```
+
+Cover:
+- Capture hook → BM25 storage → session-start injection
+- `tasks/lessons.md` compound learning
+- Auto chat recall hook
+- Cost wins via prompt cache (Anthropic 10% cached tokens)
+
+---
+
+### Thread 4 — MCP Server Deep Dive (Week 3)
+
+```
+npx kodelyth-ecc mcp
+
+This one command gives ANY agent framework access to:
+• 70 specialist agents
+• 194 skills
+• 377 addressable resources
+• Local self-learning memory
+
+Thread: what the ECC MCP server exposes 🧵
+```
+
+Cover:
+- 16 tools with one-liners each
+- 6 prompts (routing-rule is the key one)
+- Claude Desktop config snippet
+- LangGraph / AutoGen integration
+
+---
+
+### Thread 5 — Bundles Explained (Week 3)
+
+```
+3 modes. One install.
+
+npx kodelyth-ecc --bundle indie-hacker
+npx kodelyth-ecc --bundle red-team
+npx kodelyth-ecc --bundle enterprise
+
+What each one does 🧵
+```
+
+---
+
+### Standalone Tweets (sprinkle daily)
+
+**Hook tweets (rotate):**
+```
+I described a bug in plain English.
+The AI routed itself to the right expert.
+It fixed the root cause.
+I never typed a command.
+
+That's Kodelyth ECC.
+npx kodelyth-ecc
+```
+
+```
+Zero telemetry.
+Zero cloud.
+Zero tracking.
+
+All 70 agents. All 194 skills.
+All local. Verifiable with sha256 manifest.
+
+npx kodelyth-ecc verify
+```
+
+```
+The dashboard is my favorite part.
+
+npx kodelyth-ecc dashboard
+→ http://127.0.0.1:5747
+→ memory store browsable
+→ all agents searchable
+→ session history
+→ SSE live updates
+
+Localhost only. Zero telemetry. Always free.
+```
+
+```
+I used to lose solutions across projects.
+
+Now when I type a question, my AI checks if
+I solved something similar before. Automatically.
+
+BM25 local memory. No embeddings. No cloud.
+Sub-millisecond recall.
+
+github.com/sifxprime/kodelyth-ecc
+```
+
+```
+Real parallel agents.
+Not "I'll simulate multiple perspectives."
+
+/devil-mode fires 8 actual agents simultaneously.
+Each with its own playbook, bash patterns, severity calibration.
+Results aggregated into one report.
+
+That's the difference.
+```
+
+---
+
+## PHASE 4 — LinkedIn Campaign (Weeks 1-4)
+
+### Post 1 — Professional Launch Post
+
+```
+I've been quietly building Kodelyth ECC for the past year.
+
+Today I'm making some noise about it.
+
+It's a production-grade AI coding toolkit. Here's what makes it different from everything else:
+
+Most toolkits give you a folder of markdown personas. You memorize names. You type slash commands. You do the routing.
+
+ECC does the routing for you.
+
+70 specialist agents. 194 skills. 97 commands. You describe your problem in plain English — the right expert fires automatically via a 10-tier semantic intent routing system.
+
+New in v1.7.0:
+→ MCP Server: 16 tools, 6 prompts, 377 resources. Any framework that speaks Model Context Protocol can consume the full ECC stack.
+→ Local observability dashboard at localhost:5747
+→ 336 tests passing across 24 test files
+
+Works with Claude Code, Windsurf, Cursor, Codex CLI, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, and Gemini CLI.
+
+Zero telemetry. Everything on your disk. Verifiable.
+
+npx kodelyth-ecc
+
+github.com/sifxprime/kodelyth-ecc
+
+#AI #DeveloperTools #AIAgents #MCP #OpenSource
+```
+
+### Post 2 — Security Focus (Week 2)
+
+Target: security engineers, enterprise devs
+
+```
+Before you go open-source, run this:
+
+/devil-mode --pre-public
+
+It fires 8 adversarial agents in parallel:
+• secret-hunter — leaked credentials in git history
+• supply-chain-auditor — malicious deps / typosquats
+• license-violation-finder — GPL contamination
+• code-stealer-detector — IP / provenance audit
+• backdoor-hunter — obfuscated code patterns
+• prompt-injection-hunter — AI feature attack surface
+• jailbreak-tester — live AI red-team
+• chaos-engineer — fault injection planning
+
+Every one ships with real bash-grep patterns, severity calibration, and remediation playbooks.
+
+This is Kodelyth ECC's devil mode. And it runs locally. Zero telemetry. No API keys.
+
+#Security #DevSecOps #RedTeam #OpenSource
+```
+
+### Post 3 — Enterprise Focus (Week 3)
+
+Target: engineering managers, CTOs, compliance teams
+
+```
+Your team uses 4-5 AI tools. Each one has its own:
+→ Account
+→ Cloud sync
+→ Telemetry
+→ Pricing
+
+Kodelyth ECC replaces all of them with one npm install.
+
+70 specialist agents. Local BM25 memory. 336-test CI. Supply chain verification (CycloneDX SBOM). Zero telemetry.
+
+The enterprise bundle adds:
+→ SBOM generation
+→ License compliance sweep  
+→ Supply chain audit
+→ Dependency CVE scanning
+
+npx kodelyth-ecc --bundle enterprise
+
+#Engineering #CTO #DevTools #Enterprise
+```
+
+### Post 4 — MCP / Agentic Focus (Week 3)
+
+Target: AI/ML engineers building agents
+
+```
+LangGraph. AutoGen. CrewAI. OpenAI Agents SDK. Claude Desktop.
+
+They all speak MCP now.
+
+npx kodelyth-ecc mcp
+
+→ 16 tools (route_intent, recall_memory, get_agent, audit_skill_match…)
+→ 6 prompts (full intent routing rule, handoff chains, devil-mode)
+→ 377 resources (every agent, skill, command via kodelyth:// URIs)
+
+Drop it in Claude Desktop in 30 seconds:
+
+{
+  "mcpServers": {
+    "kodelyth-ecc": {
+      "command": "npx",
+      "args": ["-y", "kodelyth-ecc", "mcp"]
+    }
+  }
+}
+
+Local-only. Zero telemetry. MIT.
+
+#MCP #ModelContextProtocol #AIAgents #LLM
+```
+
+---
+
+## PHASE 5 — Reddit Campaign (Weeks 1-4)
+
+### Subreddits to target
+
+| Subreddit | Post angle |
+|---|---|
+| r/ClaudeAI | Intent routing + agents for Claude Code users |
+| r/ChatGPT | MCP server + memory system |
+| r/artificial | Devil mode + adversarial security |
+| r/programming | MCP server launch + 336 tests |
+| r/webdev | Parallel agents + team-review |
+| r/devops | Dashboard + swarm orchestrator |
+| r/netsec | Devil mode deep dive |
+| r/LocalLLaMA | Zero telemetry + local memory angle |
+| r/SideProject | Indie hacker bundle + personal story |
+| r/learnprogramming | Intent routing — no need to remember names |
+| r/ExperiencedDevs | Compound memory + hooks quality gates |
+| r/MachineLearning | MCP server integration patterns |
+| r/openai | MCP + OpenAI Agents SDK integration |
+
+### Post template for r/ClaudeAI
+
+**Title:** I built a Claude Code toolkit with 70 specialist agents and semantic intent routing — describe your problem in plain English, it routes you automatically
+
+**Body:**
+```
+I've been working on Kodelyth ECC for a while and just pushed v1.7.0.
+
+The core idea: most "agent kits" are markdown folders you have to memorize. 
+ECC reads what you write and picks the right specialist.
+
+You say "I've been staring at this bug for 2 hours" → routes to debug-detective.
+You paste a stack trace with no context → routes to debug-detective.
+You say "help me build a todo app" → fires /project-launch (5 founding-team agents in parallel).
+
+What ships:
+- 70 specialist agents
+- 194 skills  
+- 97 commands (8 parallel multi-agent)
+- 22+ hooks (quality gates, memory capture/inject, correction encoding)
+- Local BM25 self-learning memory (zero deps, zero cloud)
+- MCP server (16 tools, 377 resources — works with Claude Desktop)
+- Local observability dashboard (localhost:5747)
+- 336 tests
+
+Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and 6 more.
+
+One install: npx kodelyth-ecc
+
+GitHub: github.com/sifxprime/kodelyth-ecc
+
+Happy to answer anything about how the intent routing works or the memory architecture.
+```
+
+### Post template for r/netsec
+
+**Title:** Devil Mode: 8 adversarial agents that red-team your codebase before you ship
+
+**Body:**
+```
+I added 8 adversarial agents to my open-source AI coding toolkit.
+
+Each one thinks like an attacker. They all run in parallel.
+
+/devil-mode --pre-public fires:
+1. secret-hunter — credential leak sweep (git history + env vars + bundled client code)
+2. supply-chain-auditor — typosquats, lockfile drift, CVE-in-deps, install-script inspection
+3. license-violation-finder — GPL/AGPL contamination, missing attribution
+4. code-stealer-detector — provenance audit on AI-generated / pasted code
+5. backdoor-hunter — obfuscated eval, suspicious base64, unexplained outbound
+6. prompt-injection-hunter — indirect injection in RAG, tool hijacking, system prompt leak
+7. jailbreak-tester — live red-team of AI features (overrefusal + bypass)
+8. chaos-engineer — fault injection planning, hidden assumptions
+
+Every one ships with real grep patterns, not theatrical personas.
+
+/devil-mode --all runs all 8. /devil-mode runs 4 (the most commonly needed).
+
+Zero telemetry. Everything runs locally.
+
+github.com/sifxprime/kodelyth-ecc
+
+[r/netsec: not seeking upvotes — genuinely curious if the patterns match what you've seen in real audits]
+```
+
+---
+
+## PHASE 6 — Dev.to / Hashnode Articles (Weeks 2-4)
+
+### Article 1 — Feature article (Dev.to canonical)
+
+**Title:** `I got tired of memorizing agent names. So I built semantic intent routing for 70 AI specialists.`
+
+**Outline:**
+1. The problem: every AI toolkit needs you to remember syntax
+2. The solution: 10-tier priority intent routing
+3. How it works technically (the routing rule file, semantic matching)
+4. Real examples: frustration → debug-detective, stack trace → debug-detective, "help me build" → /project-launch
+5. Multi-agent chains: what gets suggested after each agent
+6. Install: `npx kodelyth-ecc`
+7. Conclusion: what I'm building next
+
+**Tags:** `ai`, `productivity`, `claude`, `tools`
+
+---
+
+### Article 2 — Devil Mode (Dev.to)
+
+**Title:** `8 adversarial agents that red-team your code before you ship`
+
+**Outline:**
+1. Why security reviews fail: they happen after, by the same person who wrote the code
+2. The adversarial mindset: what an attacker looks for
+3. Each of the 8 devil-mode agents with real examples
+4. /devil-mode --pre-public walkthrough
+5. Integration with CI/CD
+6. Zero telemetry design
+
+---
+
+### Article 3 — Memory System (Hashnode)
+
+**Title:** `Local AI memory that compounds: how BM25 + hooks create a self-improving development loop`
+
+**Outline:**
+1. The memory problem: AI forgets everything between sessions
+2. BM25 local memory: why keyword search beats embeddings for code
+3. Auto-capture hook: how corrections become rules automatically
+4. Session-start injection: stable prefix for prompt cache savings
+5. tasks/lessons.md: the simplest compound learning primitive
+6. Real numbers: memory after 3 months of use
+7. Privacy: why local-only matters
+
+---
+
+### Article 4 — MCP Server (Dev.to)
+
+**Title:** `npx kodelyth-ecc mcp — giving any agent framework access to 70 specialists and local memory`
+
+**Outline:**
+1. What MCP is and why it matters for multi-framework workflows
+2. What the ECC MCP server exposes: tools, prompts, resources
+3. Claude Desktop config in 30 seconds
+4. LangGraph integration example
+5. AutoGen integration example
+6. The route_intent tool: letting your orchestrator pick the right ECC agent
+7. Memory roundtrip: capture → recall across frameworks
+
+---
+
+## PHASE 7 — Hacker News (Week 2)
+
+### Show HN Post
+
+**Title:** `Show HN: Kodelyth ECC — 70 AI coding agents with semantic routing, local memory, and a devil-mode adversarial crew`
+
+**Body:**
+```
+Hi HN,
+
+I've been building Kodelyth ECC — a local-first AI coding toolkit that ships with 70 specialist agents, 194 skills, 97 commands, local BM25 self-learning memory, and 8 adversarial "devil mode" agents that audit your code like an attacker would.
+
+The core idea that differentiates it: semantic intent routing. You describe your problem in plain English, and the toolkit maps your words to the right specialist agent across a 10-tier priority system. You never need to remember agent names, but you're taught the explicit form after each automatic routing so the system teaches you as you use it.
+
+What just shipped in v1.7.0:
+- MCP server (npx kodelyth-ecc mcp): 16 tools, 6 prompts, 377 resources — lets any MCP-compatible client (Claude Desktop, LangGraph, AutoGen, CrewAI, OpenAI Agents SDK) consume the full ECC stack
+- Dashboard hardening: DNS rebinding protection, shell injection fix (execFileSync), CSP headers, SSE client cap
+- 336 tests across 24 test files
+
+Design principles I care about:
+- Zero telemetry — everything stays on your disk, verifiable with npx kodelyth-ecc verify
+- No cloud dependency — local BM25 memory, no embeddings, no API calls for recall
+- No auto-apply anything — the self-evolving memory proposes but never commits
+
+npm: npx kodelyth-ecc
+GitHub: github.com/sifxprime/kodelyth-ecc
+
+Happy to discuss the routing system design, the memory architecture, or the devil mode agent patterns.
+```
+
+**Expected HN criticism to address proactively in comments:**
+- "Is this just a prompt kit?" → No — show the hooks, tests, MCP server, dashboard
+- "Why not use X?" → Routing + memory + zero telemetry combination doesn't exist elsewhere
+- "What's the actual quality of agents?" → 336 tests, specific bash patterns, severity calibration
+- "Privacy?" → `ls -la ~/.kodelyth/memory/` — that's all there is
+
+---
+
+## PHASE 8 — Community Seeding (Ongoing)
+
+### Discord/Slack communities to join and post in
+
+| Community | Post angle |
+|---|---|
+| Claude Discord | Routing demo + memory system |
+| Windsurf Discord | .windsurfrules + parallel agents |
+| Cursor Forum | cursor-project install + rules |
+| AI Hackathon groups | MCP server + LangGraph integration |
+| Dev.to community | Articles (see Phase 6) |
+| Anthropic community | MCP + Claude Code agents |
+| OpenAI forum | MCP + OpenAI Agents SDK integration |
+| Security communities | Devil mode demos |
+| Indie Hackers forum | Indie hacker bundle + ship-fast workflow |
+| TLDR newsletter | Submit for "Cool Tools" section |
+
+### Indie Hackers Post
+
+**Title:** `I built a self-improving AI coding toolkit: 70 agents, compound memory, devil mode. Here's the architecture.`
+
+**Angle:** Personal story of building + what makes it different + honest numbers + ship fast with indie-hacker bundle
+
+---
+
+## PHASE 9 — YouTube / Video Content (Month 2)
+
+### Video 1 — 5-min demo: "Install in 60 seconds. Watch it route itself."
+
+Script outline:
+1. `npx kodelyth-ecc` — install
+2. Open Claude Code
+3. Type: "I'm stuck on this weird bug, can't figure it out" → show routing
+4. Paste a stack trace → show automatic debug-detective routing
+5. Type: "help me build a REST API" → show /project-launch firing 5 agents
+6. Show the dashboard: `npx kodelyth-ecc dashboard`
+7. Show memory recall working on a second session
+
+### Video 2 — "Devil Mode in action: I audited my own codebase"
+
+Walkthrough: run `/devil-mode --pre-public` on a real project, explain each finding
+
+### Video 3 — "How the compound memory works"
+
+Technical deep-dive on BM25, the capture hook, session-start injection, prompt cache savings
+
+### Video 4 — "MCP server: give LangGraph access to 70 agents"
+
+Live coding: wire the ECC MCP server into a LangGraph workflow
+
+---
+
+## PHASE 10 — SEO / Discoverability
+
+### npm Keywords (already in package.json — verify these all pull traffic)
+Target search terms on npmjs.com:
+- `claude-code agents`
+- `ai coding toolkit`
+- `windsurf rules`
+- `model context protocol server`
+- `developer tools llm`
+- `self learning ai`
+- `local memory ai`
+
+### GitHub Topics (add all of these)
+`claude-code` `windsurf` `cursor` `ai-agents` `llm` `mcp` `model-context-protocol` `developer-tools` `coding-toolkit` `devil-mode` `red-team` `local-memory` `self-learning` `intent-routing` `parallel-agents` `bm25` `hooks` `slash-commands` `productivity` `opencode` `codex` `antigravity`
+
+### Backlink targets
+- Awesome Claude lists on GitHub (submit PR to be listed)
+- Awesome MCP servers list (submit PR)
+- Awesome AI Agents list (submit PR)
+- Dev.to tags: #claudecode #mcp #aitools
+- Roadmap.sh community tools section
+
+---
+
+## PHASE 11 — Influencer / Partnership Outreach
+
+### Target profiles to reach (personalized DM approach)
+
+**Claude Code focused devs** (X/Twitter):
+- Developers who post frequently about Claude Code — offer early access, ask for honest review
+- Message angle: "You post about Claude Code. I built infrastructure on top of it — 70 agents with routing. I'd love your honest opinion."
+
+**Security / DevSecOps influencers:**
+- Message angle: "Devil mode — 8 adversarial agents. Would love your take on whether these patterns match real audit work."
+
+**Indie hackers with newsletters:**
+- Message angle: "Indie hacker bundle — ship fast, validate, then harden with /devil-mode --pre-public. Worth a mention in your next issue?"
+
+**MCP / AI framework builders:**
+- Message angle: "ECC MCP server exposes 377 resources and 16 tools. Could plug right into what you're building. Want a demo?"
+
+### DM template (X)
+
+```
+Hey [name] — I built Kodelyth ECC, an AI coding toolkit with 70 agents and semantic routing.
+
+You post a lot about [Claude Code / security / AI agents]. I think the [devil mode / routing system / MCP server] might be relevant to what you cover.
+
+Zero telemetry, MIT, everything local.
+npx kodelyth-ecc if you want to try it.
+
+Happy to do a live demo or answer questions. No pressure either way.
+```
+
+---
+
+## PHASE 12 — Email / Newsletter Outreach
+
+### TLDR Newsletter (developer audience, 1M+ subscribers)
+Submit via their cool tools submission form.
+
+**Submission:**
+```
+Kodelyth ECC — 70 AI coding agents with semantic intent routing, local memory, and devil mode
+
+One npm install gives you 70 specialist AI coding agents that fire automatically when you describe your problem in plain English. Ships with local BM25 memory (compounds across sessions), 8 adversarial "devil mode" security agents, a real-time localhost dashboard, and an MCP server that works with Claude Desktop, LangGraph, and AutoGen.
+
+Zero telemetry. Fully verifiable. npx kodelyth-ecc
+```
+
+### Bytes.dev Newsletter
+Submit for "Cool Tools" section — targets JavaScript developers.
+
+### Console.dev
+Submit for weekly dev tools digest — well-read by senior engineers.
+
+---
+
+## CONTENT CALENDAR — 30-day plan
+
+| Day | Platform | Content |
+|---|---|---|
+| 1 | GitHub | Upload social preview image, verify all topics |
+| 1 | X | Launch thread (Thread 1 — 8 tweets) |
+| 1 | LinkedIn | Post 1 — Professional launch post |
+| 2 | Reddit r/ClaudeAI | Show-and-tell post |
+| 2 | Reddit r/programming | MCP server launch post |
+| 3 | X | Devil mode standalone tweet |
+| 3 | Discord (Claude) | Share routing demo |
+| 4 | Dev.to | Article 1 — Intent routing |
+| 5 | X | Memory system tweet |
+| 5 | Reddit r/LocalLLaMA | Zero telemetry + local memory angle |
+| 6 | GitHub | Create 10 good-first-issues |
+| 7 | X | Thread 2 — Devil mode deep dive |
+| 7 | Hacker News | Show HN post |
+| 8 | LinkedIn | Post 2 — Security focus |
+| 9 | Reddit r/netsec | Devil mode post |
+| 10 | X | Dashboard tweet with screenshot |
+| 11 | Hashnode | Article 3 — Memory system |
+| 12 | X | Thread 3 — Memory deep dive |
+| 12 | Product Hunt | LAUNCH DAY |
+| 13 | X | Share PH link + #ProductHunt |
+| 13 | All communities | Push PH upvote day |
+| 14 | LinkedIn | Post 3 — Enterprise bundle |
+| 15 | Dev.to | Article 2 — Devil mode |
+| 16 | X | MCP server tweet |
+| 17 | Reddit r/MachineLearning | MCP + agent frameworks |
+| 18 | LinkedIn | Post 4 — MCP server |
+| 19 | X | Thread 4 — MCP deep dive |
+| 20 | Dev.to | Article 4 — MCP server |
+| 21 | X | Bundles explained tweet |
+| 22 | Reddit r/SideProject | Personal story + indie bundle |
+| 23 | Indie Hackers | Full post |
+| 24 | X | Thread 5 — Bundles |
+| 25 | Newsletter submissions | TLDR, Bytes.dev, Console.dev |
+| 26 | X | Compound learning tweet |
+| 27 | GitHub Discussions | Create welcome discussion |
+| 28 | X | 336 tests / credibility tweet |
+| 29 | LinkedIn | Retrospective post (month 1 learnings) |
+| 30 | X | "What are you using ECC for?" engagement tweet |
+
+---
+
+## METRICS TO TRACK
+
+| Metric | Target (30 days) | Tool |
+|---|---|---|
+| GitHub stars | 500+ | GitHub insights |
+| npm downloads | 2000+/week | npmjs.com stats |
+| Product Hunt rank | Top 5 of the day | PH |
+| HN Show HN points | 100+ | HN |
+| Dev.to article views | 5000+ each | Dev.to analytics |
+| Twitter/X impressions | 500k+ total | X analytics |
+| LinkedIn impressions | 100k+ total | LinkedIn analytics |
+| GitHub forks | 50+ | GitHub |
+| Contributors | 5+ | GitHub |
+| Discord/community members | 100+ | Discord |
+
+---
+
+## KEY MESSAGES (use in every post, adapt tone to platform)
+
+1. **The routing hook:** "Describe your problem. The right expert fires. You never need to remember names."
+2. **The numbers hook:** "70 agents. 194 skills. 97 commands. One install."
+3. **The privacy hook:** "Zero telemetry. Zero cloud. `npx kodelyth-ecc verify` — your sha256 manifest, fully auditable."
+4. **The devil hook:** "8 adversarial agents that read your code like an attacker. `/devil-mode --pre-public` before you go open source."
+5. **The memory hook:** "Your AI remembered how you fixed a Stripe bug 5 months ago. BM25. Local. No embeddings."
+6. **The speed hook:** "/team-review: 4 agents in parallel. 60 minutes → 15 minutes. That's the whole pitch."
+7. **The MCP hook:** "Any framework that speaks MCP now has access to 70 agents and local memory. `npx kodelyth-ecc mcp`."
+
+---
+
+## WHAT NOT TO DO
+
+- **Don't** say "AI-powered" without specifics (everyone says that)
+- **Don't** lead with the feature count without the benefit
+- **Don't** post the same message on every platform — adapt tone
+- **Don't** spam communities — one quality post per subreddit per week max
+- **Don't** ask for stars in every post — ask for honest feedback instead (stars follow)
+- **Don't** ignore replies — every comment is a chance to show depth
+- **Don't** exaggerate claims — the real numbers (70 agents, 336 tests, MCP server) are impressive enough
+
+---
+
+*Plan owner: Shofiqul Islam (@sifxprime)*  
+*Repo: github.com/sifxprime/kodelyth-ecc*  
+*npm: npmjs.com/package/kodelyth-ecc*

package/VERSION

@@ -1 +1 @@
-1.7.0
+1.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 194 skills, 97 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",

package/wiki/FAQ.md

@@ -6,7 +6,7 @@
 
 **What is Kodelyth ECC?**
 
-An AI coding toolkit (v1.7.0) that installs into 12 AI coding platforms. It adds 70 specialist agents (including 8 adversarial devil-mode agents), 194 skills, 97 slash commands, 20+ automation hooks, and a compound learning system. Zero cloud, zero telemetry, all local.
+An AI coding toolkit (v1.7.1) that installs into 11 AI coding platforms (13 install targets). It adds 70 specialist agents (including 8 adversarial devil-mode agents), 194 skills, 97 slash commands, 20+ automation hooks, and a compound learning system. Zero cloud, zero telemetry, all local.
 
 **Is it free?**
 

package/wiki/Home.md

@@ -2,7 +2,7 @@
 
 **Kodelyth Enhanced Coding Companion** — production-grade AI coding toolkit for Claude Code, Windsurf, Cursor, Codex CLI, Google Antigravity, and more.
 
-> Version: **v1.7.0** · Agents: **70** (including 8 adversarial) · Skills: **194** · Commands: **97** (including 8 parallel) · Hooks: **22+** · Platforms: **12** · Tests: **336**
+> Version: **v1.7.2** · Agents: **70** (including 8 adversarial) · Skills: **194** · Commands: **97** (including 8 parallel) · Hooks: **22+** · Platforms: **11** · Tests: **336**
 
 ---