kodelyth-ecc 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -2,6 +2,116 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.5.2 — Parallel Agents + Cross-Platform Lessons + AI Image Generation (May 2026)
+
+### The Parallel Era
+
+ECC becomes fully multi-platform and multi-agent. Five agents can now run simultaneously on a single task. Image generation works natively on every platform. Lessons work everywhere, not just Claude Code.
+
+### Added
+
+#### `image-architect` agent — Platform-aware AI image generation
+- **Google Antigravity**: uses Gemini Imagen 3 natively — no API key, no setup
+- **Codex CLI**: uses DALL-E 3 natively — no API key, no setup
+- **Claude Code**: fal.ai MCP → SVG fallback
+- **Windsurf / Cursor**: native model image gen → fal.ai → SVG fallback
+- Knows exact dimensions for every use case: hero (1920×1080), OG (1200×630), Twitter (1200×675), LinkedIn (1584×396), square (1080×1080), GitHub preview (1280×640)
+- Full prompt engineering guide built in — structured prompts for photorealistic and illustrated styles
+- Always produces SVG fallback alongside AI-generated images
+- Can generate full social kit (5 assets) in one command
+
+#### `/project-launch` command — Parallel founding team for new projects
+- Fires 5 agents simultaneously: `architect` + `pair-programmer` + `security-reviewer` + `tdd-guide` + `ux-reviewer`
+- Each agent gets focused narrow context → cheaper per agent, runs in parallel
+- Aggregated **Project Launch Report** with architecture, risk, threat model, test strategy, UX blueprint
+- `--full` flag adds `performance-optimizer` + `api-guardian`
+- Wall-clock time: ~10 min vs ~45 min sequential
+
+#### `/team-review` command — Parallel full audit for existing projects
+- Fires 4 agents simultaneously: `code-reviewer` + `security-reviewer` + `performance-optimizer` + `api-guardian`
+- Scope options: whole repo, directory, `--changed` (git diff only), `--pre-release`
+- Aggregated **Team Review Report** with severity ratings (CRITICAL / HIGH / MEDIUM / LOW)
+- `--pre-release` adds `release-captain` for ship-readiness check
+- Wall-clock time: ~15 min vs ~60 min sequential
+
+#### `/lessons` command — Cross-platform project lessons
+- Works on ALL platforms: Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode
+- `/lessons` — load and apply all lessons from `tasks/lessons.md` for this session
+- `/lessons save` — extract corrections from current session, confirm, write to file
+- `/lessons add "<rule>"` — add a manual rule instantly
+- `/lessons clear` — review and prune stale rules
+- On Claude Code: already automatic via hooks. On all other platforms: one command loads everything.
+
+### Updated
+
+- `rules/common/self-improvement-workflow.md` — added explicit cross-platform lesson loading instructions. Non-Claude-Code platforms instructed to proactively read `tasks/lessons.md` at session start.
+- `rules/common/agent-intent-routing.md` — added routing patterns for `image-architect`, `/project-launch`, `/team-review`, `/lessons`. Added 7 new example routing decisions.
+
+### Token and Time Economics
+
+| Operation | Sequential | Parallel (`/project-launch` or `/team-review`) |
+|---|---|---|
+| New project analysis | ~45 min, 1 large context | ~10 min, 5 focused contexts |
+| Full codebase audit | ~60 min, 1 large context | ~15 min, 4 focused contexts |
+| Token cost | 1 full session | ~2× tokens, cached prefix = ~10% on system prompt |
+| Net | Slower, more tokens per insight | Faster, cheaper per insight |
+
+---
+
+## v1.5.1 — Compound Learning System (May 2026)
+
+### The Self-Improvement Loop
+
+Every correction you make to Claude gets encoded permanently into your project. Next session, Claude doesn't repeat the mistake. The month after, it matches how you think. After a year, it works like a team member who has been here for years.
+
+### New: Three-Layer Compound Memory Architecture
+
+| Layer | File | Scope | How it works |
+|---|---|---|---|
+| Project Lessons | `tasks/lessons.md` | Per-project | Hard rules from your corrections. Injected at session start. |
+| Global Memory | `~/.kodelyth/memory/` | Cross-project | BM25 fuzzy recall of past solutions. Auto-fires on every prompt. |
+| Intent Routing | 61 agents | Always-on | Routes your message to the right specialist from the first word. |
+
+### Added
+
+#### `hooks/memory/capture-correction.js` (Stop hook)
+- Scans session JSONL for user correction patterns (12 signal types: "no don't", "use X instead", "stop doing Y", "we always", "wrong approach", etc.)
+- Extracts corrections as hard rules and appends to `tasks/lessons.md` in the project root
+- Runs async at session end — zero latency impact
+- Self-deduplicates: same rule never written twice
+
+#### `hooks/memory/read-lessons.js` (SessionStart hook)
+- Reads `tasks/lessons.md` at session start and injects rules as high-priority context
+- Detects project tech stack (Node.js + framework, Go, Rust, Python, Java) and injects a project DNA brief
+- Reads open items from `tasks/todo.md` and surfaces them at session start
+- Fires before all other hooks — lessons are always loaded first
+
+#### `rules/common/self-improvement-workflow.md`
+- Encodes Boris Cherny's internal Claude Code team workflow (6 patterns)
+- Extended with ECC's three-layer compound memory architecture
+- Plan Node Default, Subagent Strategy, Self-Improvement Loop, Verification Before Done, Demand Elegance, Autonomous Bug Fixing
+- Task Management Protocol: `tasks/todo.md` + `tasks/lessons.md` as first-class project artifacts
+
+### How Addiction Works
+
+```
+Session 1:  You say "use pnpm not npm"
+            → capture-correction.js writes: "- use pnpm not npm" to tasks/lessons.md
+
+Session 2:  read-lessons.js fires at start
+            → "PROJECT LESSONS — HARD RULES" injected into context
+            → Claude uses pnpm without being told
+
+Month 1:    10+ lessons stacked
+            → Claude matches your style, your conventions, your preferences
+
+Month 3:    You open another AI tool
+            → It feels like a new hire who knows nothing about your project
+            → You come back
+```
+
+---
+
 ## v1.5.0 — Incident Response + Load Testing + Complete Visual Refresh (May 2026)
 
 ### Added — 2 New Specialist Agents

package/README.md

@@ -8,13 +8,13 @@
 ![Antigravity](https://img.shields.io/badge/Antigravity-Ready-00ADD8)
 ![Cursor](https://img.shields.io/badge/Cursor-Ready-3b82f6)
 ![Codex](https://img.shields.io/badge/Codex-Ready-10b981)
-![Version](https://img.shields.io/badge/version-1.5.0-orange)
-![Agents](https://img.shields.io/badge/Agents-61-brightgreen)
+![Version](https://img.shields.io/badge/version-1.5.2-orange)
+![Agents](https://img.shields.io/badge/Agents-62-brightgreen)
 ![Skills](https://img.shields.io/badge/Skills-188-brightgreen)
 ![Memory](https://img.shields.io/badge/Local%20Memory-on-blueviolet)
 ![Auto Recall](https://img.shields.io/badge/Auto%20Chat%20Recall-on-blueviolet)
-![Incident Response](https://img.shields.io/badge/Incident%20Commander-new-red)
-![Load Testing](https://img.shields.io/badge/Load%20Tester-new-yellow)
+![Parallel Agents](https://img.shields.io/badge/Parallel%20Agents-new-red)
+![Image Generation](https://img.shields.io/badge/AI%20Image%20Gen-new-yellow)
 
 </div>
 
@@ -212,22 +212,91 @@ See `skills/kodelyth-memory/SKILL.md` for the full design + CLI reference.
 
 ---
 
+## Compound Learning System — Self-Improvement Loop (new in v1.5.1)
+
+Every correction you give Claude gets encoded into your project permanently. The toolkit gets smarter every session without any effort from you.
+
+```
+Session 1:  You type "use pnpm not npm"
+            → Session ends
+            → capture-correction.js scans the JSONL
+            → Writes to tasks/lessons.md: "- use pnpm not npm"
+
+Session 2:  read-lessons.js fires at session start
+            → Injects: "PROJECT LESSONS — HARD RULES: - use pnpm not npm"
+            → Claude uses pnpm without being told
+
+Month 1:    10+ corrections stacked
+            → Claude knows your naming style, preferred patterns, tech opinions
+            → Zero ramp-up time on any new task
+
+Month 3:    You try another tool
+            → It uses npm. It uses the wrong pattern. It asks basic questions.
+            → You come back.
+```
+
+### Three-layer compound memory architecture
+
+| Layer | File | Scope | How it works |
+|---|---|---|---|
+| **Project Lessons** | `tasks/lessons.md` | Per-project | Hard rules from your corrections. Injected at session start as mandatory context. |
+| **Global Memory** | `~/.kodelyth/memory/` | Cross-project | BM25 fuzzy recall of past solutions. Auto-fires on every prompt you type. |
+| **Intent Routing** | 61 agents | Always-on | Routes your message to the right specialist from the first word. No names needed. |
+
+### How it works under the hood
+
+**`capture-correction.js`** — Stop hook, runs async at session end:
+- Scans session JSONL for 12 correction signal patterns (`"no don't"`, `"use X instead"`, `"stop doing Y"`, `"we always"`, `"wrong approach"`, etc.)
+- Extracts them as plain-language rules
+- Appends them to `tasks/lessons.md` with date grouping
+- Creates the file automatically if it doesn't exist
+
+**`read-lessons.js`** — SessionStart hook, fires first before any other hook:
+- Reads `tasks/lessons.md` and formats rules as `PROJECT LESSONS — HARD RULES` block
+- Detects project DNA automatically: Node.js + framework (Next.js, React, NestJS, etc.), Go, Rust, Python, Java/Gradle, package manager (pnpm/bun/yarn/npm), test runner
+- Surfaces open `tasks/todo.md` items into session context
+- All injected as `additionalContext` — Claude sees it before your first message
+
+**`rules/common/self-improvement-workflow.md`** — always-on rule:
+- Boris Cherny's (Claude Code creator) internal team workflow, all 6 patterns
+- Plan Node Default, Subagent Strategy, Self-Improvement Loop, Verification Before Done, Demand Elegance, Autonomous Bug Fixing
+- Extended with ECC's three-layer compound memory protocol
+
+### `tasks/lessons.md` — your project's rulebook
+
+Edit it freely. Add rules manually. Remove rules that no longer apply. It's a plain markdown file at `tasks/lessons.md` in your project root. The more corrections you give, the more precisely it matches how you work.
+
+```markdown
+# Claude Lessons
+
+Project: **my-app**
+
+## 2026-05-06
+
+- use pnpm not npm
+- never add try/catch without logging the error first
+- we use Zod for validation, not Yup
+- component files go in src/components, not src/app
+```
+
+---
+
 ## What's Inside
 
 | Component | Count | Description |
 |---|---|---|
-| Agents | **61** | Specialist subagents — reviewers, planners, debuggers, architects, incident-commander, load-tester, memory |
+| Agents | **62** | Specialist subagents — reviewers, planners, debuggers, architects, incident-commander, load-tester, memory, image-architect |
 | Skills | **188** | Domain knowledge — patterns, testing, security, DevOps, intent routing, memory |
 | Commands | **80** | Slash command workflows (`/tdd`, `/plan`, `/memory`, etc.) |
-| Hooks | **18+** | Quality gates, secret scanning, branch checks, memory inject + capture |
-| Rules | **16** | Always-on coding standards + intent routing + memory protocol |
+| Hooks | **20+** | Quality gates, secret scanning, branch checks, memory inject + capture + correction + project DNA |
+| Rules | **17** | Always-on coding standards + intent routing + memory protocol + self-improvement workflow |
 | Memory | **local** | BM25-indexed personal memory at `~/.kodelyth/memory/` (zero deps) |
 
 ---
 
 ## Agent Arsenal
 
-### Kodelyth Exclusives — The 15 Agents That Make ECC
+### Kodelyth Exclusives — The 16 Agents That Make ECC
 
 | Agent | One-line job |
 |---|---|
@@ -246,6 +315,15 @@ See `skills/kodelyth-memory/SKILL.md` for the full design + CLI reference.
 | `release-captain` | Owns the release ritual — semver, tagging, publishing, rollback |
 | `env-debugger` | "Works on my machine" hunter — env, config, secrets, layers |
 | `flake-hunter` | Stabilizes flaky tests — never adds blind retries |
+| `image-architect` | AI image generation — Gemini/DALL-E/fal.ai/SVG, platform-aware |
+
+### Parallel Commands — New in v1.5.2
+
+| Command | What it does | Time saved |
+|---|---|---|
+| `/project-launch` | Fires 5 founding-team agents simultaneously on a new project | 45 min → 10 min |
+| `/team-review` | Fires 4 audit agents simultaneously on existing code | 60 min → 15 min |
+| `/lessons` | Loads project lessons on any platform (cross-platform) | Works everywhere |
 
 ### Agent Categories
 
@@ -273,7 +351,10 @@ Once installed (Claude Code target), these hooks run automatically with zero con
 
 | Hook | What it does |
 |---|---|
-| Session start | Loads context from previous session |
+| Session start — lessons | Reads `tasks/lessons.md` and injects your hard rules + project DNA as context *(v1.5.1)* |
+| Session start — memory | Loads relevant past solutions from global BM25 memory |
+| Auto chat recall | Watches every prompt, injects relevant memories before AI responds |
+| Correction capture | Detects when you correct Claude, encodes the rule to `tasks/lessons.md` *(v1.5.1)* |
 | Pre-commit | Catches `console.log`, secrets, bad commit messages |
 | Quality gate | Runs type checks and formatting after edits |
 | Git push reminder | Prompts review before pushing |
@@ -281,7 +362,6 @@ Once installed (Claude Code target), these hooks run automatically with zero con
 | Desktop notify | macOS notification when a long task finishes |
 | MCP health check | Validates MCP servers before calling them |
 | Test reminder | Prompts to write tests when code is edited without tests |
-| Smart suggest | After each response, suggests the next logical agent |
 | Branch name check | Blocks git branches that don't match naming convention |
 
 ---
@@ -460,7 +540,22 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for templates, checklists, and the full K
 
 ## Changelog
 
-See [CHANGELOG.md](CHANGELOG.md). v1.5.0 highlights:
+See [CHANGELOG.md](CHANGELOG.md). v1.5.2 highlights:
+
+- **Added:** `image-architect` agent — platform-aware AI image generation. Gemini Imagen 3 on Antigravity, DALL-E 3 on Codex, fal.ai on Claude Code, SVG fallback everywhere
+- **Added:** `/project-launch` — 5 founding-team agents fire in parallel for new projects (45 min → 10 min)
+- **Added:** `/team-review` — 4 audit agents fire in parallel for existing code (60 min → 15 min)
+- **Added:** `/lessons` command — cross-platform lesson loading, works on Windsurf, Cursor, Codex, Antigravity, OpenCode
+- **Updated:** intent routing with image generation, parallel commands, and lessons patterns
+
+v1.5.1 highlights:
+
+- **Added:** `capture-correction.js` Stop hook — detects 12 correction signal patterns in session JSONL, encodes them as hard rules to `tasks/lessons.md` automatically at session end
+- **Added:** `read-lessons.js` SessionStart hook — injects `tasks/lessons.md` rules + project DNA (stack, framework, package manager, open todos) as session context before first message
+- **Added:** `rules/common/self-improvement-workflow.md` — Boris Cherny's internal Claude Code team workflow (6 patterns) + ECC three-layer compound memory architecture
+- **Architecture:** Three-layer compound memory — `tasks/lessons.md` (project-local) + `~/.kodelyth/memory/` (global BM25) + 61 agents (intent routing)
+
+v1.5.0 highlights:
 
 - **Added:** `incident-commander` — production incident response (triage, containment, postmortem) — distinct from `debug-detective`
 - **Added:** `load-tester` — load/stress testing with k6, Locust, Artillery — distinct from `performance-optimizer`

package/SECURITY.md

@@ -4,8 +4,12 @@
 
 | Version | Supported |
 |---------|-----------|
-| 1.1.x   | Yes — active |
-| 1.0.x   | No — upgrade to 1.1.x |
+| 1.5.x   | Yes — current stable |
+| 1.4.x   | Yes — security fixes only |
+| 1.3.x   | Yes — security fixes only |
+| 1.2.x   | No — upgrade to 1.5.x |
+| 1.1.x   | No — upgrade to 1.5.x |
+| 1.0.x   | No — upgrade to 1.5.x |
 | < 1.0   | No |
 
 ---

package/VERSION

@@ -1 +1 @@
-1.5.0
+1.5.2

package/agents/image-architect.md

@@ -0,0 +1,190 @@
+---
+name: image-architect
+description: AI image generation specialist. Generates hero sections, OG images, social cards, thumbnails, and UI mockups. Platform-aware — uses native image generation on Antigravity (Gemini Imagen 3) and Codex (DALL-E 3), fal.ai MCP on Claude Code and Windsurf, and falls back to production-quality SVG on any platform with no API key. Knows exact dimensions, aspect ratios, and prompt engineering for every use case.
+tools: [Bash, Write, Read]
+---
+
+# image-architect
+
+You are an AI image generation specialist. You generate production-quality images for web products — hero sections, OG cards, social thumbnails, UI mockups, and marketing assets. You are platform-aware: you use the best image generation capability available on whatever platform the user is running.
+
+---
+
+## Platform Detection — Use Native First
+
+Before generating anything, identify the platform and pick the right generation method:
+
+### Google Antigravity (Gemini)
+Gemini has **native image generation** via Imagen 3. Use it directly — no API key needed, no extra setup.
+
+```
+Generate an image using Imagen 3:
+Prompt: [your optimised prompt]
+Aspect ratio: [ratio]
+```
+
+Imagen 3 produces photorealistic and illustrated images at high quality. Use it as the primary method on Antigravity.
+
+### OpenAI Codex CLI
+Codex runs on GPT-4o which has access to **DALL-E 3** natively. Use it directly.
+
+```
+Generate an image with DALL-E 3:
+Prompt: [your optimised prompt]
+Size: [1792x1024 for landscape / 1024x1024 for square / 1024x1792 for portrait]
+Quality: hd
+Style: natural (for photos) or vivid (for illustrations)
+```
+
+DALL-E 3 is the default on Codex — no configuration needed.
+
+### Claude Code
+Use **fal.ai MCP** if configured. Check with:
+```bash
+# If fal-ai MCP is in ~/.claude.json, it's available
+```
+If fal.ai is available: use `fal-ai/flux/schnell` (fast) or `fal-ai/flux-pro` (highest quality).
+If not: fall back to production SVG.
+
+### Windsurf / Cursor
+Check if the configured model supports image generation (GPT-4o → DALL-E 3, Gemini → Imagen).
+If not: use fal.ai MCP if configured, otherwise SVG fallback.
+
+### Any Platform — SVG Fallback
+When no image generation API is available: produce a **production-quality SVG** that rivals designed graphics. SVG is always available, instant, zero cost, and infinitely scalable.
+
+---
+
+## Generation Priority by Platform
+
+| Platform | 1st choice | 2nd choice | Always available |
+|---|---|---|---|
+| Google Antigravity | Gemini Imagen 3 (native) | fal.ai | SVG |
+| Codex CLI | DALL-E 3 (native) | fal.ai | SVG |
+| Claude Code | fal.ai MCP | — | SVG |
+| Windsurf | GPT-4o/DALL-E or Gemini/Imagen | fal.ai | SVG |
+| Cursor | GPT-4o/DALL-E or Gemini/Imagen | fal.ai | SVG |
+| OpenCode | fal.ai | — | SVG |
+
+---
+
+## Prompt Engineering
+
+Great prompts = great images. Always structure prompts with:
+
+**For photorealistic (hero, product, team):**
+```
+[subject], [style], [lighting], [composition], [mood], [technical quality]
+Example: "Developer at workstation, cinematic lighting, shallow depth of field,
+dark moody atmosphere, electric blue monitor glow, sharp focus on hands and keyboard"
+```
+
+**For illustrated / graphic (OG cards, social, thumbnails):**
+```
+[style] illustration of [subject], [color palette], [composition], [brand feel]
+Example: "Flat design illustration of interconnected AI agents, electric purple and
+cyan on dark navy, geometric shapes, minimal, tech startup aesthetic"
+```
+
+**Negative prompt (always include for AI models):**
+```
+blurry, watermark, text, low quality, pixelated, distorted faces, extra limbs
+```
+
+**Imagen 3 specific:** Describe scenes in natural English. Detailed is better. Include "high resolution", "professional", "commercial photography style" for photorealistic.
+
+**DALL-E 3 specific:** Use "vivid" style for illustrations, "natural" for photos. DALL-E 3 follows instructions very literally — be specific about what NOT to include.
+
+---
+
+## Aspect Ratios by Use Case
+
+| Use case | Dimensions | Notes |
+|---|---|---|
+| Hero section (desktop) | 1920×1080 | 16:9, save as `public/images/hero.jpg` |
+| OG / social preview | 1200×630 | GitHub, Twitter, Facebook, WhatsApp |
+| Twitter / X card | 1200×675 | 16:9 crop of OG |
+| Facebook post | 1200×630 | Same as OG |
+| LinkedIn banner | 1584×396 | 4:1 panoramic |
+| Square post | 1080×1080 | Instagram, universal |
+| Product thumbnail | 800×600 | 4:3 |
+| Mobile hero | 1080×1920 | 9:16 portrait |
+| GitHub social preview | 1280×640 | 2:1 exact |
+
+---
+
+## SVG Fallback — Production Standard
+
+When generating SVG (no image API available or user prefers it):
+
+- Use `<linearGradient>` / `<radialGradient>` for depth and atmosphere
+- Use `<filter>` with `feGaussianBlur` for glow effects on key elements
+- Use `<defs>` to keep the file clean
+- Match brand colors from `package.json`, README, or ask the user
+- Typography: use `font-family="'Segoe UI', system-ui, -apple-system, sans-serif"`
+- Always include `viewBox` for responsive scaling — no hardcoded pixel sizes in layout
+- Keep files under 50KB — complex art belongs in AI-generated formats
+- No placeholder boxes — every element should look intentional and designed
+
+---
+
+## Deliverables by Request Type
+
+### Hero section
+- AI image: 1920×1080, saved to `public/images/hero.jpg` or `public/hero.png`
+- SVG version: same composition as lightweight vector at `public/images/hero.svg`
+- CSS tip: `background: linear-gradient(to bottom, transparent 60%, #000 100%)` over the image for text legibility
+
+### OG / GitHub / social preview
+- 1200×630 with: product name, tagline, logo area, brand gradient
+- Works as-is on GitHub, Twitter, Facebook, LinkedIn, WhatsApp preview cards
+- Save as `public/og-image.svg` (SVG) or `public/og-image.png` (AI-generated)
+
+### Full social kit (when user asks for complete set)
+Generate all 5 in sequence:
+1. OG card — 1200×630
+2. Twitter/X card — 1200×675
+3. Facebook post — 1200×630
+4. LinkedIn banner — 1584×396
+5. Square post — 1080×1080
+
+### Product thumbnail / feature card
+- 800×600 or square depending on use case
+- Clean, icon-forward composition
+- Consistent palette with the brand
+
+---
+
+## Workflow
+
+1. Identify the platform (Antigravity → Gemini, Codex → DALL-E 3, Claude Code → fal.ai/SVG)
+2. Ask (or infer from context): what is this image for? what is the product/brand?
+3. Confirm dimensions and style direction with one short question
+4. Generate the optimised prompt
+5. Produce the image (native) or SVG
+6. Save to the appropriate path and report what was created
+7. Ask: "Want any adjustments — colors, mood, composition, text overlay?"
+
+---
+
+## Intent Routing Triggers
+
+The routing rule will send users here when they say:
+- "generate a hero image / banner / thumbnail"
+- "I need an OG image / social preview / GitHub card"
+- "make a social card / cover image"
+- "create product visuals / marketing images"
+- "design a header / background image"
+- "generate images for the landing page"
+- "create a GitHub social preview"
+- "I need visuals / artwork / graphics"
+
+---
+
+## Constraints
+
+- Never generate images of real people by name
+- Never generate NSFW content
+- Always save files to `public/`, `assets/`, or `src/assets/` depending on the project structure
+- Always produce an SVG version alongside AI-generated images
+- When unsure of brand colors, ask before generating — wrong colors waste API credits

package/commands/lessons.md

@@ -0,0 +1,92 @@
+---
+description: Load, view, and save project lessons from tasks/lessons.md. Works on ALL platforms — Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode.
+---
+
+# /lessons — Project Self-Improvement
+
+Cross-platform command for the Compound Learning System. Works everywhere, with or without hooks.
+
+## Usage
+
+```
+/lessons              → load and show all lessons for this session
+/lessons save         → extract corrections from this session and write to tasks/lessons.md
+/lessons add "<rule>" → add a manual rule immediately
+/lessons clear        → show lessons and ask which to remove
+```
+
+## What This Command Does
+
+### `/lessons` (no args) — Load lessons
+
+1. Check if `tasks/lessons.md` exists in the project root
+2. Read all lesson rules (lines starting with `-`)
+3. Inject them as **PROJECT LESSONS — HARD RULES** for this session
+4. Print a summary of how many rules are active
+5. Apply them immediately — do not wait for another message
+
+If `tasks/lessons.md` does not exist yet, say:
+> "No lessons file found. Corrections you give me this session will build it. Run `/lessons save` at the end of the session to write them."
+
+### `/lessons save` — Capture session corrections
+
+Scan the current conversation for user corrections:
+- Phrases matching: "no don't", "use X instead", "stop doing Y", "wrong approach", "we always", "we never", "I told you", "that's not how we", "use X not Y"
+- Extract each as a plain-language rule
+- Show the extracted rules to the user before writing
+- Ask: "Write these N rules to tasks/lessons.md?"
+- On confirmation: create `tasks/` if needed, append rules with today's date
+
+### `/lessons add "<rule>"` — Add a manual rule
+
+Immediately append the rule to `tasks/lessons.md`:
+```
+## 2026-05-06
+- <rule>
+```
+Confirm: "Rule added. It will be active from the next session (or reload with /lessons)."
+
+### `/lessons clear` — Review and prune
+
+Show all current rules numbered. Ask: "Which numbers to remove? (e.g. 1,3,5 or 'all')"
+Remove selected lines and rewrite the file.
+
+## Format of tasks/lessons.md
+
+```markdown
+# Claude Lessons
+
+Project: **project-name**
+
+Auto-generated by Kodelyth ECC. Edit freely — add, remove, reword. These are YOUR rules.
+
+---
+
+## 2026-05-06
+
+- use pnpm not npm
+- never add try/catch without logging the error first
+- we use Zod for validation, not Yup
+
+## 2026-05-10
+
+- component files go in src/components, not src/app
+- always use early returns, never deeply nested if blocks
+```
+
+## Platform Notes
+
+| Platform | Auto-load at start | Auto-capture at end | Manual via /lessons |
+|---|---|---|---|
+| Claude Code | Yes (SessionStart hook) | Yes (Stop hook) | Yes |
+| Windsurf | No | No | Yes — run `/lessons` at start of every session |
+| Cursor | No | No | Yes — run `/lessons` at start of every session |
+| Codex CLI | No | No | Yes — run `/lessons` at start of every session |
+| Antigravity | No | No | Yes — run `/lessons` at start of every session |
+| OpenCode | No | No | Yes — run `/lessons` at start of every session |
+
+**Tip for non-Claude-Code platforms:** Add `/lessons` as your first message in every session on this project. Takes 2 seconds and loads all your hard-earned rules instantly.
+
+## Arguments
+
+$ARGUMENTS

package/commands/project-launch.md

@@ -0,0 +1,74 @@
+---
+description: Parallel founding-team blast for new projects. Fires architect + security + UX + TDD + pair-programmer simultaneously. One command, 5 specialist reports at once.
+---
+
+# /project-launch — Parallel Founding Team
+
+Launch all founding-team agents in parallel on your new project. What would take 40+ minutes sequentially finishes in under 10 minutes as one parallel burst.
+
+## Usage
+
+```
+/project-launch <description>
+/project-launch "SaaS dashboard with Stripe billing, user auth, real-time data"
+/project-launch --full    # adds performance-optimizer and api-guardian to the team
+```
+
+## What Gets Launched in Parallel
+
+Five specialist agents fire simultaneously, each with the same project description:
+
+| Agent | Deliverable |
+|---|---|
+| `architect` | System design — components, data flow, boundaries, trade-offs |
+| `pair-programmer` | Approach validation — risks, wrong turns, questions to answer before coding |
+| `security-reviewer` | Threat model — auth, data exposure, OWASP risks for THIS project type |
+| `tdd-guide` | Test strategy — what to test first, test pyramid, critical paths |
+| `ux-reviewer` | UX blueprint — user flows, accessibility requirements, interaction risks |
+
+With `--full`, also adds:
+- `performance-optimizer` — scaling bottlenecks, caching strategy, query patterns
+- `api-guardian` — API contract design, versioning strategy, breaking change risks
+
+## How It Works
+
+1. Read the project description from `$ARGUMENTS`
+2. If no description provided, ask for one in one sentence
+3. Spawn all 5 (or 7) agents simultaneously with `run_in_background: true`
+4. Each agent receives: the project description + its specialist brief
+5. Wait for all to complete
+6. Aggregate results into a structured **Project Launch Report**:
+
+```
+## PROJECT LAUNCH REPORT
+### Architecture (architect)
+[findings]
+
+### Approach Risks (pair-programmer)
+[findings]
+
+### Threat Model (security-reviewer)
+[findings]
+
+### Test Strategy (tdd-guide)
+[findings]
+
+### UX Blueprint (ux-reviewer)
+[findings]
+```
+
+7. After report: ask "Which area do you want to go deeper on first?"
+
+## Token Efficiency
+
+Each agent gets a **narrow, focused context** — just the project description + its specialist instructions. No agent carries the full conversation history. The system prompt (rules + agents) is cached across all parallel agents. Result: 5× the analysis at roughly 2× the token cost of a single sequential session.
+
+## When to Use
+
+- Starting any non-trivial project (3+ components, real users, production intent)
+- Before writing a single line of code
+- When you want to catch architecture mistakes before they're baked in
+
+## Arguments
+
+$ARGUMENTS