kodelyth-ecc 1.5.0 → 1.5.2

package/commands/team-review.md

@@ -0,0 +1,90 @@
+---
+description: Parallel full-team audit for existing projects. Fires code-reviewer + security-reviewer + performance-optimizer + api-guardian simultaneously. One command, complete audit at once.
+---
+
+# /team-review — Parallel Full-Team Audit
+
+Run a full audit of your existing codebase with 4 specialist agents firing simultaneously. What would take an hour sequentially takes 15 minutes in parallel.
+
+## Usage
+
+```
+/team-review                    # full audit — all 4 agents on entire codebase
+/team-review src/auth/          # focus all agents on a specific directory
+/team-review --changed          # audit only files changed since last commit
+/team-review --pre-release      # adds release-captain for release readiness check
+```
+
+## What Gets Launched in Parallel
+
+| Agent | Focus |
+|---|---|
+| `code-reviewer` | Quality, patterns, dead code, naming, complexity, maintainability |
+| `security-reviewer` | OWASP Top 10, secrets, injection, auth gaps, CVEs in deps |
+| `performance-optimizer` | N+1 queries, unbounded loops, missing indexes, memory leaks, bundle size |
+| `api-guardian` | Breaking changes, missing validation, versioning gaps, contract drift |
+
+With `--pre-release`, also adds:
+- `release-captain` — release readiness: changelog, semver, rollback plan, smoke test coverage
+
+## How It Works
+
+1. Identify the target scope (whole repo, directory, or changed files)
+2. Spawn all 4 agents simultaneously with `run_in_background: true`
+3. Each agent scans its assigned concern independently
+4. Wait for all to complete
+5. Aggregate into a structured **Team Review Report**:
+
+```
+## TEAM REVIEW REPORT
+
+### Code Quality (code-reviewer)
+CRITICAL: [list]
+HIGH:     [list]
+MEDIUM:   [list]
+
+### Security (security-reviewer)
+CRITICAL: [list]
+HIGH:     [list]
+
+### Performance (performance-optimizer)
+HIGH:     [list]
+MEDIUM:   [list]
+
+### API Contracts (api-guardian)
+BREAKING: [list]
+WARN:     [list]
+
+---
+TOTAL: X critical, Y high, Z medium
+RECOMMENDATION: [ship / fix critical first / block]
+```
+
+6. After report: "Which finding do you want to fix first?"
+
+## Severity Levels
+
+| Level | Meaning | Action |
+|---|---|---|
+| CRITICAL | Security vulnerability, data loss, production breakage | Block — fix before merge |
+| HIGH | Bug, broken contract, significant perf regression | Fix before shipping |
+| MEDIUM | Maintainability debt, minor perf, code smell | Fix when convenient |
+| LOW | Style, suggestion | Optional |
+
+## When to Use
+
+- Before any major PR merge
+- Pre-release audit
+- Onboarding to an unfamiliar codebase (run `/team-review` to get the full picture fast)
+- After a large refactor
+- Monthly health check on long-running projects
+
+## Time and Token Efficiency
+
+Sequential audit (4 agents one by one): ~40–60 minutes, full context per agent.
+`/team-review` parallel: ~10–15 minutes, narrow focused context per agent.
+System prompt cached across all agents → each pays 10% on that prefix.
+
+## Arguments
+
+$ARGUMENTS

package/hooks/hooks.json

@@ -168,6 +168,19 @@
       }
     ],
     "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/read-lessons.js\"",
+            "async": false,
+            "timeout": 4
+          }
+        ],
+        "description": "Kodelyth ECC: inject project lessons (tasks/lessons.md) and project DNA as hard rules at session start",
+        "id": "kodelyth:session:start:read-lessons"
+      },
       {
         "matcher": "*",
         "hooks": [
@@ -340,6 +353,19 @@
       }
     ],
     "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/capture-correction.js\"",
+            "async": true,
+            "timeout": 8
+          }
+        ],
+        "description": "Kodelyth ECC: detect user corrections in session and encode them as hard rules to tasks/lessons.md (Self-Improvement Loop)",
+        "id": "kodelyth:stop:capture-correction"
+      },
       {
         "matcher": "*",
         "hooks": [
@@ -375,7 +401,7 @@
             "timeout": 300
           }
         ],
-        "description": "Batch format (Biome/Prettier) and typecheck (tsc) all JS/TS files edited this response — runs once at Stop instead of after every Edit",
+        "description": "Batch format (Biome/Prettier) and typecheck (tsc) all JS/TS files edited this response \u2014 runs once at Stop instead of after every Edit",
         "id": "stop:format-typecheck"
       },
       {
@@ -458,4 +484,4 @@
       }
     ]
   }
-}
+}

package/hooks/memory/capture-correction.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Correction Capture Hook (Stop)
+//
+// Runs at the end of every Claude Code session. Scans the session JSONL for
+// user messages that contain corrections (e.g. "no don't", "use X instead",
+// "stop doing Y", "wrong approach"). Extracts them as hard rules and appends
+// them to tasks/lessons.md in the project root.
+//
+// This is the engine behind the Self-Improvement Loop:
+//   User corrects Claude → rule encoded → next session it doesn't repeat it
+//
+// Output contract: always pass stdin through to stdout. Never block a session.
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+// ── Correction signal patterns ─────────────────────────────────────────────
+const CORRECTION_SIGNALS = [
+  /\bno[,.]?\s+(don'?t|do not|never|stop|that'?s)/i,
+  /\bthat'?s?\s+(wrong|incorrect|not right|not what I|not how I)/i,
+  /\b(don'?t|do not|never)\s+(do that|use that|write that|add that|put that)/i,
+  /\b(stop|avoid)\s+(doing|using|writing|adding|calling)/i,
+  /\binstead[,\s]\s*(use|do|write|call|import|prefer)/i,
+  /\b(wrong approach|bad approach|hacky|not the right way|not how we do)/i,
+  /\b(I said|I told you|I asked you)\s+(not to|to not|don'?t|to use|to avoid)/i,
+  /\b(always|never)\s+(use|do|write|prefer|avoid|import|call)\b/i,
+  /\buse\s+\w[\w-]*\s+(not|instead of|rather than)\s+\w/i,
+  /\b(we use|we prefer|we don'?t use|we never|we always)\b/i,
+  /\b(please don'?t|please use|please avoid|please stop)\b/i,
+  /\bthat'?s not (what|how|the way)/i,
+];
+
+// ── Messages that look like corrections but are questions ──────────────────
+const EXCLUDE_PATTERNS = [
+  /\?$/,
+  /^(what|how|why|when|where|which|who|can you|could you|would you|should I)/i,
+];
+
+// ── Minimum message length to bother with ─────────────────────────────────
+const MIN_LEN = 8;
+
+// ── Entry point ───────────────────────────────────────────────────────────
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', run);
+setTimeout(() => { if (!process.stdin.readableEnded) run(); }, 150);
+
+function run() {
+  // Always pass stdin through — never block a session
+  if (raw) process.stdout.write(raw);
+
+  try {
+    const payload = raw ? JSON.parse(raw) : {};
+    const sessionJsonl = payload.session_path
+      || payload.transcript_path
+      || findLatestSession(payload.cwd || process.cwd());
+
+    if (!sessionJsonl || !fs.existsSync(sessionJsonl)) return;
+
+    const corrections = extractCorrections(sessionJsonl);
+    if (corrections.length === 0) return;
+
+    writeToLessons(corrections, payload.cwd || process.cwd());
+  } catch (err) {
+    process.stderr.write(`[ecc:correction-capture] ${err.message}\n`);
+  }
+}
+
+// ── Extract corrections from session JSONL ─────────────────────────────────
+function extractCorrections(sessionJsonl) {
+  const lines = fs.readFileSync(sessionJsonl, 'utf8').split('\n').filter(Boolean);
+  const corrections = [];
+
+  for (const line of lines) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+
+    // Only process user turns
+    if (event.type !== 'user') continue;
+
+    const text = extractText(event);
+    if (!text || text.length < MIN_LEN) continue;
+
+    // Skip if it looks like a question
+    if (EXCLUDE_PATTERNS.some(p => p.test(text.trim()))) continue;
+
+    // Check for correction signals
+    if (!CORRECTION_SIGNALS.some(p => p.test(text))) continue;
+
+    // Clean up and cap length
+    const cleaned = text.trim().replace(/\s+/g, ' ').slice(0, 300);
+    corrections.push(cleaned);
+  }
+
+  // Deduplicate
+  return [...new Set(corrections)];
+}
+
+// ── Pull plain text from an event ─────────────────────────────────────────
+function extractText(event) {
+  const content = event.message?.content ?? event.content ?? '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter(b => b.type === 'text')
+      .map(b => b.text || '')
+      .join(' ')
+      .trim();
+  }
+  return '';
+}
+
+// ── Write lessons to tasks/lessons.md ─────────────────────────────────────
+function writeToLessons(corrections, cwd) {
+  const tasksDir = path.join(cwd, 'tasks');
+  const lessonsFile = path.join(tasksDir, 'lessons.md');
+
+  try {
+    fs.mkdirSync(tasksDir, { recursive: true });
+
+    const isNew = !fs.existsSync(lessonsFile);
+    const date  = new Date().toISOString().split('T')[0];
+    const project = path.basename(cwd);
+
+    let header = '';
+    if (isNew) {
+      header = [
+        '# Claude Lessons',
+        '',
+        `Project: **${project}**`,
+        '',
+        'Auto-generated by Kodelyth ECC. Each entry is a rule Claude learned from a correction.',
+        'Edit freely — add, remove, reword. These are YOUR rules.',
+        '',
+        '---',
+        '',
+      ].join('\n');
+    }
+
+    const block = [
+      `## ${date}`,
+      '',
+      ...corrections.map(c => `- ${c}`),
+      '',
+    ].join('\n');
+
+    fs.appendFileSync(lessonsFile, header + block, 'utf8');
+
+    process.stderr.write(
+      `[ecc:correction-capture] ${corrections.length} lesson(s) written to tasks/lessons.md\n`
+    );
+  } catch (err) {
+    process.stderr.write(`[ecc:correction-capture] Could not write lessons: ${err.message}\n`);
+  }
+}
+
+// ── Find the latest session JSONL for this project ────────────────────────
+function findLatestSession(cwd) {
+  try {
+    const os = require('os');
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(projectsDir)) return null;
+
+    const encoded = cwd.replace(/\//g, '-');
+    const dirs = fs.readdirSync(projectsDir)
+      .filter(d => encoded.endsWith(d.slice(-20)) || d.endsWith(encoded.slice(-30)));
+
+    if (dirs.length === 0) return null;
+
+    const projectDir = path.join(projectsDir, dirs[0]);
+    const sessions = fs.readdirSync(projectDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => ({ f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+
+    return sessions[0] ? path.join(projectDir, sessions[0].f) : null;
+  } catch {
+    return null;
+  }
+}

package/hooks/memory/read-lessons.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Lessons + Project DNA Hook (SessionStart)
+//
+// Runs at the start of every Claude Code session. Does two things:
+//
+//   1. LESSONS: Reads tasks/lessons.md from the project root (if it exists)
+//      and injects the encoded rules as high-priority context. These are
+//      corrections the user made in past sessions — hard rules, not soft
+//      suggestions. Claude MUST follow them for this session.
+//
+//   2. PROJECT DNA: Detects the tech stack, package manager, and key
+//      conventions from the project root (package.json, go.mod, Cargo.toml,
+//      etc.) and injects a concise project brief so Claude doesn't need to
+//      re-discover basics each session.
+//
+// Output contract: emit { additionalContext: "..." } to stdout.
+// Never block a session — exit 0 even on any error.
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', run);
+setTimeout(() => { if (!process.stdin.readableEnded) run(); }, 150);
+
+function run() {
+  try {
+    const payload = raw ? JSON.parse(raw) : {};
+    const projectRoot = payload.cwd || payload.project_root || process.cwd();
+
+    const parts = [];
+
+    const lessons = readLessons(projectRoot);
+    if (lessons) parts.push(lessons);
+
+    const dna = buildProjectDNA(projectRoot);
+    if (dna) parts.push(dna);
+
+    if (parts.length === 0) {
+      process.exit(0);
+    }
+
+    process.stdout.write(JSON.stringify({
+      additionalContext: parts.join('\n\n---\n\n'),
+      meta: { source: 'kodelyth-ecc:read-lessons', hasLessons: !!lessons, hasDNA: !!dna },
+    }));
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`[ecc:read-lessons] ${err.message}\n`);
+    process.exit(0);
+  }
+}
+
+// ── Read tasks/lessons.md and format as hard rules ────────────────────────
+function readLessons(projectRoot) {
+  const lessonsFile = path.join(projectRoot, 'tasks', 'lessons.md');
+  if (!fs.existsSync(lessonsFile)) return null;
+
+  const content = fs.readFileSync(lessonsFile, 'utf8').trim();
+  if (!content) return null;
+
+  // Extract all bullet rules across all dated sections
+  const rules = content
+    .split('\n')
+    .filter(line => line.match(/^-\s+.{5,}/))
+    .map(line => line.trim())
+    .filter(Boolean);
+
+  if (rules.length === 0) return null;
+
+  return [
+    '## PROJECT LESSONS — HARD RULES (from past corrections)',
+    '',
+    'These rules were encoded from corrections made in previous sessions.',
+    'You MUST follow them for this entire session. They override generic defaults.',
+    '',
+    rules.join('\n'),
+  ].join('\n');
+}
+
+// ── Detect project tech stack and conventions ─────────────────────────────
+function buildProjectDNA(projectRoot) {
+  const facts = [];
+
+  // Node / JS / TS
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const name = pkg.name || path.basename(projectRoot);
+      facts.push(`Project: ${name} (Node.js / JavaScript)`);
+
+      // Package manager
+      if (fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))) {
+        facts.push('Package manager: pnpm');
+      } else if (fs.existsSync(path.join(projectRoot, 'bun.lockb')) || fs.existsSync(path.join(projectRoot, 'bun.lock'))) {
+        facts.push('Package manager: bun');
+      } else if (fs.existsSync(path.join(projectRoot, 'yarn.lock'))) {
+        facts.push('Package manager: yarn');
+      } else {
+        facts.push('Package manager: npm');
+      }
+
+      // Framework detection
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const frameworks = [];
+      if (deps.next) frameworks.push(`Next.js ${deps.next}`);
+      if (deps.react) frameworks.push(`React ${deps.react}`);
+      if (deps.vue) frameworks.push(`Vue ${deps.vue}`);
+      if (deps.svelte) frameworks.push(`Svelte`);
+      if (deps.express) frameworks.push(`Express ${deps.express}`);
+      if (deps.fastify) frameworks.push(`Fastify`);
+      if (deps.nestjs || deps['@nestjs/core']) frameworks.push('NestJS');
+      if (deps.typescript || deps['ts-node']) frameworks.push('TypeScript');
+      if (deps.prisma || deps['@prisma/client']) frameworks.push('Prisma');
+      if (deps.drizzle) frameworks.push('Drizzle ORM');
+      if (frameworks.length > 0) facts.push(`Stack: ${frameworks.join(', ')}`);
+
+      // Test runner
+      if (deps.jest) facts.push('Test runner: Jest');
+      else if (deps.vitest) facts.push('Test runner: Vitest');
+      else if (deps.mocha) facts.push('Test runner: Mocha');
+    } catch {}
+  }
+
+  // Go
+  const goModPath = path.join(projectRoot, 'go.mod');
+  if (fs.existsSync(goModPath)) {
+    try {
+      const goMod = fs.readFileSync(goModPath, 'utf8');
+      const moduleLine = goMod.match(/^module (.+)/m);
+      const goVersion  = goMod.match(/^go (.+)/m);
+      facts.push(`Project: ${moduleLine?.[1] || 'Go module'} (Go${goVersion ? ' ' + goVersion[1] : ''})`);
+    } catch {}
+  }
+
+  // Rust
+  const cargoPath = path.join(projectRoot, 'Cargo.toml');
+  if (fs.existsSync(cargoPath)) {
+    try {
+      const cargo = fs.readFileSync(cargoPath, 'utf8');
+      const name  = cargo.match(/^name\s*=\s*"(.+)"/m);
+      facts.push(`Project: ${name?.[1] || 'Rust crate'} (Rust / Cargo)`);
+    } catch {}
+  }
+
+  // Python
+  const reqPath   = path.join(projectRoot, 'requirements.txt');
+  const pyprojPath = path.join(projectRoot, 'pyproject.toml');
+  if (fs.existsSync(reqPath) || fs.existsSync(pyprojPath)) {
+    facts.push('Language: Python');
+    if (fs.existsSync(path.join(projectRoot, 'poetry.lock'))) facts.push('Package manager: Poetry');
+    else if (fs.existsSync(path.join(projectRoot, 'Pipfile.lock'))) facts.push('Package manager: Pipenv');
+    else facts.push('Package manager: pip');
+  }
+
+  // Java / Kotlin
+  if (fs.existsSync(path.join(projectRoot, 'build.gradle')) || fs.existsSync(path.join(projectRoot, 'build.gradle.kts'))) {
+    facts.push('Build: Gradle (Java / Kotlin)');
+  }
+  if (fs.existsSync(path.join(projectRoot, 'pom.xml'))) {
+    facts.push('Build: Maven (Java)');
+  }
+
+  // Existing tasks/todo.md
+  const todoPath = path.join(projectRoot, 'tasks', 'todo.md');
+  if (fs.existsSync(todoPath)) {
+    const todo = fs.readFileSync(todoPath, 'utf8').trim();
+    const openItems = todo.split('\n').filter(l => l.match(/^-\s*\[ \]/)).slice(0, 5);
+    if (openItems.length > 0) {
+      facts.push('');
+      facts.push('Open tasks (from tasks/todo.md):');
+      openItems.forEach(item => facts.push(item.trim()));
+    }
+  }
+
+  if (facts.length === 0) return null;
+
+  return [
+    '## PROJECT DNA (auto-detected)',
+    '',
+    facts.join('\n'),
+  ].join('\n');
+}

package/install.sh

@@ -47,7 +47,7 @@ echo -e "${RED}${BOLD}  ║   DANGER LEVEL: GOD TIER    ·    NOT FOR JUNIOR DEV
 echo -e "${RED}${BOLD}  ╚══════════════════════════════════════════════════════════════╝${RESET}"
 echo ""
 echo -e "${BOLD}  Kodelyth ECC — The most dangerous AI coding toolkit on the planet${RESET}"
-echo -e "${CYAN}  59 specialist agents  ·  188 skills  ·  80 commands  ·  18+ hooks  ·  intent routing  ·  local memory${RESET}"
+echo -e "${CYAN}  61 specialist agents  ·  188 skills  ·  80 commands  ·  20+ hooks  ·  intent routing  ·  compound memory${RESET}"
 echo -e "${CYAN}  Any language  ·  Any framework  ·  Any scale  ·  300B-level quality${RESET}"
 echo ""
 echo -e "  github.com/sifxprime/kodelyth-ecc"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.5.0",
-  "description": "Production-grade AI coding toolkit — 61 agents, 188 skills, 80 commands, god-tier intent routing, local self-learning memory with auto chat detection, incident response, load testing. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
+  "version": "1.5.2",
+  "description": "Production-grade AI coding toolkit \u2014 61 agents, 188 skills, 80 commands, god-tier intent routing, local self-learning memory with auto chat detection, incident response, load testing. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
   "repository": {
@@ -24,7 +24,11 @@
     "auto-recall",
     "incident-response",
     "load-testing",
-    "kodelyth"
+    "kodelyth",
+    "image-generation",
+    "parallel-agents",
+    "multi-agent",
+    "project-launch"
   ],
   "bin": {
     "kodelyth-ecc": "bin/kodelyth-ecc.js"

package/rules/common/agent-intent-routing.md

@@ -313,11 +313,66 @@ Use the chain: `forker` → `sanitizer` → `packager`.
 | `load-tester` (bottleneck found) | `performance-optimizer` to fix the code |
 | `incident-commander` (incident resolved) | `debug-detective` for deeper root cause, then postmortem |
 
+### `image-architect` — Image and visual generation
+
+Trigger if the user wants any visual asset generated:
+
+| Signal | Examples |
+|---|---|
+| Hero / banner | "generate a hero image", "I need a banner", "create a header image" |
+| Social / OG | "OG image", "social preview", "GitHub card", "Twitter card", "Facebook post image" |
+| Thumbnails | "product thumbnail", "feature image", "cover image" |
+| Landing page | "visuals for landing page", "marketing images", "I need graphics" |
+| General | "generate an image", "create artwork", "I need a picture", "make a visual" |
+
+Platform routing inside `image-architect`:
+- Google Antigravity → Gemini Imagen 3 (native, no key needed)
+- Codex CLI → DALL-E 3 (native, no key needed)
+- Claude Code → fal.ai MCP → SVG fallback
+- Windsurf / Cursor → native model image gen → fal.ai → SVG fallback
+
+### `/project-launch` — New project parallel founding team
+
+Trigger when starting something new and needing full team analysis at once:
+
+| Signal | Examples |
+|---|---|
+| New project | "I'm starting a new project", "planning a new app", "building from scratch" |
+| Pre-code analysis | "analyse this before I start coding", "what should I think about first" |
+| Multiple concerns at once | Architecture + security + UX + tests all in one ask |
+
+Route to `/project-launch` — fires `architect` + `pair-programmer` + `security-reviewer` + `tdd-guide` + `ux-reviewer` simultaneously.
+
+### `/team-review` — Existing project parallel full audit
+
+Trigger when the user wants comprehensive review of existing code:
+
+| Signal | Examples |
+|---|---|
+| Full audit | "full audit of my codebase", "review everything", "complete code review" |
+| Pre-release | "before I ship", "is this ready to release", "pre-launch review" |
+| Parallel review | "check security AND performance AND code quality at once" |
+
+Route to `/team-review` — fires `code-reviewer` + `security-reviewer` + `performance-optimizer` + `api-guardian` simultaneously.
+
+### `/lessons` — Project lessons management
+
+Trigger when the user wants to work with project-level learned rules:
+
+| Signal | Examples |
+|---|---|
+| Load lessons | "load my lessons", "what rules do we have for this project", "apply lessons" |
+| Save corrections | "save what I corrected", "encode today's corrections", "write to lessons" |
+| Add a rule | "remember we always use pnpm", "add a rule: never use var" |
+
 ### Parallel suggestions
 
 If the user has a multi-faceted concern, name the parallel agents:
 - "I'm building a payment endpoint" → `pair-programmer` + `security-reviewer` + `api-guardian`
 - "Refactoring the auth module" → `refactor-cleaner` + `security-reviewer` + `tdd-guide`
+- "Starting a new project" → `/project-launch`
+- "Is this ready to ship?" → `/team-review`
+- "I need visuals for my landing page" → `image-architect`
 
 ---
 
@@ -353,6 +408,12 @@ If the user has a multi-faceted concern, name the parallel agents:
 | "will this hold under 10k concurrent users" | `load-tester` | Capacity / load testing question |
 | "run a load test before launch" | `load-tester` | Pre-launch load validation |
 | "postmortem for yesterday's outage" | `incident-commander` | Postmortem workflow |
+| "generate a hero image for my landing page" | `image-architect` | Image generation request |
+| "I need an OG image / GitHub social card" | `image-architect` | Social preview asset |
+| "create visuals for the app" | `image-architect` | Marketing asset generation |
+| "I'm starting a new SaaS project, help me plan it" | `/project-launch` | New project, all concerns at once |
+| "full audit before we ship v2" | `/team-review` | Pre-release parallel audit |
+| "load my project lessons" | `/lessons` | Cross-platform lesson loading |
 
 ---