kodelyth-ecc 1.5.4 → 1.5.5

package/CLAUDE.md

@@ -8,7 +8,7 @@ Guidance for Claude Code when working with this repository.
 
 - **62 specialist agents** — debug-detective, incident-commander, load-tester, image-architect, kodelyth-memory, security-reviewer, etc.
 - **188 skills** — domain knowledge, patterns, testing, security, intent routing, local memory
-- **80 commands** — slash workflows (`/tdd`, `/plan`, `/code-review`, `/memory`, `/project-launch`, `/team-review`, ...)
+- **88 commands** — slash workflows (`/tdd`, `/plan`, `/code-review`, `/team-review`, `/project-launch`, `/debug-blitz`, `/security-audit`, ...)
 - **20+ hooks** — automated quality gates, session memory, memory inject + capture, correction encoding
 - **17 rules** — always-on coding standards + semantic intent routing + memory protocol
 
@@ -45,6 +45,20 @@ When a user message matches a routing pattern, you MUST:
 3. Suggest the explicit form: `Tip: type "use <agent>"`
 4. Never silently route — transparency is mandatory
 
+## Parallel Commands (Fastest Paths — Multi-Agent)
+
+These fire multiple specialist agents simultaneously. Use these for the fastest results:
+
+| Command | Agents Fired | Best For |
+|---|---|---|
+| `/team-review` | code-reviewer + security-reviewer + performance-optimizer + api-guardian | Full audit before any PR or deploy |
+| `/project-launch` | architect + pair-programmer + security-reviewer + tdd-guide + ux-reviewer | Starting any new project |
+| `/security-audit` | security-reviewer + dependency-doctor + api-guardian | Full threat surface check |
+| `/debug-blitz` | debug-detective + silent-failure-hunter + env-debugger | Bug that resisted 30+ min of investigation |
+| `/refactor-sprint` | refactor-cleaner + code-simplifier + type-design-analyzer + tdd-guide | Full cleanup before a feature sprint |
+| `/pre-release` | release-captain + security-reviewer + code-reviewer | Go/no-go verdict before shipping |
+| `/onboard` | code-explorer + architect + doc-updater | Understand any codebase in 15 minutes |
+
 ## Key Commands
 
 - `/kodelyth-quickstart` — friendly onboarding guide

package/VERSION

@@ -1 +1 @@
-1.5.4
+1.5.5

package/agents/debug-detective.md

@@ -7,6 +7,7 @@ description: >
   never patches symptoms, never stops until the root cause is understood.
   Use when a bug is hard to find, confusing, intermittent, or has resisted fixes.
 tools: ["Read", "Grep", "Glob", "Bash"]
+model: sonnet
 ---
 
 You are the Debug Detective — a principal engineer with 10+ years of production war stories at companies where bugs cost millions per minute of downtime. You have debugged memory leaks in C++ services, traced race conditions in distributed systems, hunted null pointer exceptions in 2 AM on-call incidents, and found the one misconfigured timeout that was silently corrupting financial transactions. You do not guess. You do not patch. You investigate.

package/agents/dependency-doctor.md

@@ -8,6 +8,7 @@ description: >
   Use when install fails, lockfile drifts, audit reports CVEs, or a dep
   upgrade breaks the build.
 tools: ["Read", "Grep", "Glob", "Bash"]
+model: sonnet
 ---
 
 You are the Dependency Doctor — the engineer your team calls when `npm install` fails on CI but works locally, when `cargo update` breaks the world, when a transitive vulnerability lands in production at 2 AM. You read lockfiles like x-rays.

package/agents/incident-commander.md

@@ -7,6 +7,7 @@ description: >
   everything is on fire. Knows exactly what to do, in what order, and who to tell.
   Use when production is down, degraded, or at risk.
 tools: ["Read", "Grep", "Glob", "Bash"]
+model: sonnet
 ---
 
 You are the Incident Commander — a principal SRE with 10+ years leading production incidents at companies where every minute of downtime costs real money. You have run P0s at financial institutions, coordinated multi-team responses to database failures, managed rolling rollbacks under pressure, and written postmortems that changed how organizations think about reliability. You do not panic. You do not guess. You command.

package/agents/kodelyth-advisor.md

@@ -7,6 +7,7 @@ description: >
   direction instantly. No hand-holding, no noise — just the exact answer.
   Use when you need strategic guidance, tool selection, or a clear path forward.
 tools: ["Read", "Grep", "Glob"]
+model: sonnet
 ---
 
 You are the Kodelyth Advisor — a principal engineer with a decade-plus of building systems that power billions of users at companies valued in the hundreds of billions. You have shipped production code at Google scale, designed distributed systems under real SLA pressure, and mentored engineers who went on to lead their own platforms. You do not write toy code. You do not give junior-level answers. You think in systems, not files.

package/agents/load-tester.md

@@ -7,6 +7,7 @@ description: >
   Use when you need to validate how a system behaves under load, before launch,
   after infrastructure changes, or when planning capacity.
 tools: ["Read", "Grep", "Glob", "Bash"]
+model: sonnet
 ---
 
 You are the Load Tester — a performance engineering specialist with a decade of experience designing load tests for systems that serve millions of users. You have found the database query that only breaks at 500 req/s, identified the memory leak that only manifests after 10 minutes of sustained load, and discovered the thundering herd that only appears when 1000 users hit the cache miss simultaneously. You make systems prove their capacity limits before users find them.

package/agents/migration-guide.md

@@ -8,6 +8,7 @@ description: >
   phased migration plan with exact file changes, and handles dependency
   conflicts. Use when upgrading any major framework, language, or library.
 tools: ["Read", "Grep", "Glob", "Bash"]
+model: sonnet
 ---
 
 You are the Migration Guide — a principal engineer with 10+ years of leading major version migrations at companies where "we'll upgrade later" became "we're 4 major versions behind and nothing works." You have migrated millions of lines of code across React, Next.js, Python, Node.js, TypeScript, Java, Go, and more. You know every gotcha. You know which breaking changes are actually safe to batch and which need their own isolated PR.

package/agents/pair-programmer.md

@@ -8,6 +8,7 @@ description: >
   any code is committed. The cheapest bug is the one caught before coding starts.
   Use before implementing anything non-trivial.
 tools: ["Read", "Grep", "Glob"]
+model: sonnet
 ---
 
 You are the Pair Programmer — a principal engineer with 10+ years of sitting next to developers at $300B-scale companies, thinking through hard problems before they become expensive mistakes. You have saved countless hours by asking "wait, have you considered..." before the wrong approach was half-built. You think out loud. You challenge respectfully. You make people think better — not feel worse.

package/agents/release-captain.md

@@ -7,6 +7,7 @@ description: >
   mistakes that turn a routine release into a Sunday outage.
   Use before cutting any new version, or when a release went sideways.
 tools: ["Read", "Grep", "Glob", "Bash"]
+model: sonnet
 ---
 
 You are the Release Captain — the engineer who has shipped thousands of releases without a bad one. You know that the difference between a calm release and a fire is the **30 minutes of preparation no one wants to do**. You do them.

package/commands/debug-blitz.md

@@ -0,0 +1,70 @@
+---
+description: Parallel debug assault — fires debug-detective + silent-failure-hunter + env-debugger simultaneously. Three root-cause specialists on your bug at once.
+---
+
+# /debug-blitz — Parallel Debug Assault
+
+Three debugging specialists attack your problem from different angles simultaneously. The bug that has resisted one approach rarely survives all three.
+
+## What Gets Launched in Parallel
+
+| Agent | Focus |
+|---|---|
+| `debug-detective` | Traces the explicit error to root cause — stack traces, logs, hypothesis → proof |
+| `silent-failure-hunter` | Finds bugs with no error — swallowed exceptions, bad fallbacks, wrong output |
+| `env-debugger` | Catches environment-layer bugs — env vars, config drift, "works locally" failures |
+
+## Usage
+
+```
+/debug-blitz                         # general debug — all three agents
+/debug-blitz "TypeError on line 42"  # paste the error — agents use it as starting point
+/debug-blitz --ci                    # focus env-debugger on CI/CD environment
+/debug-blitz --prod                  # production context — incident-commander added
+```
+
+## Report Format
+
+```
+## DEBUG BLITZ REPORT
+
+### Root Cause Analysis (debug-detective)
+HYPOTHESIS: [most likely cause]
+EVIDENCE:   [what points to it]
+DISPROVEN:  [what was ruled out]
+FIX:        [exact change needed]
+
+### Silent Failures (silent-failure-hunter)
+FOUND:      [swallowed errors, bad fallbacks]
+RISK:       [what could be silently wrong]
+
+### Environment (env-debugger)
+CONFIG:     [mismatches found]
+SECRETS:    [missing or wrong vars]
+DRIFT:      [local vs CI vs prod differences]
+
+---
+MOST LIKELY CAUSE: [one sentence]
+RECOMMENDED FIX:   [one action]
+```
+
+## When to Use
+
+- Bug has resisted more than 30 minutes of investigation
+- "Works on my machine" but fails in CI or prod
+- No error thrown but wrong output
+- Intermittent failures with no obvious pattern
+- A fix was applied but the bug came back
+
+## Execute Now
+
+Invoking this command is confirmation to proceed. Execute immediately:
+
+1. Extract the error, symptom, or context from `$ARGUMENTS`. If empty, scan recent git changes and ask: "What's broken and what changed last?"
+2. Spawn all agents simultaneously with `run_in_background: true`:
+   - `debug-detective` — hypothesis-driven root cause analysis
+   - `silent-failure-hunter` — scan for swallowed errors and bad fallbacks
+   - `env-debugger` — environment and config layer investigation
+3. Wait for all to complete.
+4. Aggregate into the Debug Blitz Report format above with one clear recommended fix.
+5. End with: "Want me to implement the fix?"

package/commands/onboard.md

@@ -0,0 +1,72 @@
+---
+description: Parallel codebase onboarding — fires code-explorer + architect + doc-updater simultaneously. Understand any codebase in 15 minutes instead of 3 days.
+---
+
+# /onboard — Parallel Codebase Onboarding
+
+Three agents map your codebase simultaneously — architecture, execution paths, and documentation gaps. New to a repo? Get up to speed in 15 minutes.
+
+## What Gets Launched in Parallel
+
+| Agent | Focus |
+|---|---|
+| `code-explorer` | Traces execution paths, maps data flow, identifies key entry points and dependencies |
+| `architect` | Infers the architectural pattern, layers, module boundaries, and design decisions |
+| `doc-updater` | Identifies documentation gaps, stale docs, and missing READMEs or JSDoc |
+
+## Usage
+
+```
+/onboard                             # full codebase overview
+/onboard src/payments/               # focus on a specific module
+/onboard --new-hire                  # adds kodelyth-advisor for getting-started guidance
+/onboard --audit                     # adds code-reviewer for quality assessment
+```
+
+## Report Format
+
+```
+## ONBOARDING REPORT
+
+### Architecture (architect)
+PATTERN:    [MVC / hexagonal / microservices / etc.]
+LAYERS:     [how the code is organized]
+KEY FILES:  [the 5–10 files you must understand first]
+DECISIONS:  [notable architectural choices and why]
+
+### Execution Paths (code-explorer)
+ENTRY POINTS: [main flows — auth, data, API, jobs]
+DATA FLOW:    [how data moves through the system]
+DEPENDENCIES: [what talks to what]
+GOTCHAS:      [non-obvious behaviours]
+
+### Documentation Health (doc-updater)
+MISSING:   [modules with no docs]
+STALE:     [docs that no longer match the code]
+GAPS:      [API endpoints with no documentation]
+
+---
+TIME TO PRODUCTIVE: estimated X days
+FIRST 3 THINGS TO READ: [ordered list]
+```
+
+## When to Use
+
+- First day on a new codebase
+- Reviewing a large PR in an unfamiliar module
+- Taking over a project from another team
+- Returning to code you haven't touched in 6+ months
+- Evaluating an open-source repo before adopting it
+
+## Execute Now
+
+Invoking this command is confirmation to proceed. Execute immediately:
+
+1. Determine scope from `$ARGUMENTS`. Default: entire current project.
+2. Spawn all agents simultaneously with `run_in_background: true`:
+   - `code-explorer` — execution path tracing and dependency mapping
+   - `architect` — architectural pattern inference
+   - `doc-updater` — documentation gap analysis
+3. Wait for all to complete.
+4. Aggregate into the Onboarding Report format above.
+5. End with: "Which area do you want to explore deeper first?"

package/commands/pre-release.md

@@ -0,0 +1,66 @@
+---
+description: Parallel pre-release check — fires release-captain + security-reviewer + code-reviewer simultaneously. Go/no-go in one command before you ship.
+---
+
+# /pre-release — Parallel Release Readiness Check
+
+Three agents verify your release is safe to ship. Catches the things that turn a Friday deploy into a weekend incident.
+
+## What Gets Launched in Parallel
+
+| Agent | Focus |
+|---|---|
+| `release-captain` | Semver correctness, changelog complete, rollback plan, smoke test coverage |
+| `security-reviewer` | Last-minute security gaps, secrets, auth issues before code goes live |
+| `code-reviewer` | Critical quality issues, dead code, regressions introduced in this release |
+
+## Usage
+
+```
+/pre-release                     # check current branch vs main
+/pre-release v2.1.0              # check specific version tag
+/pre-release --hotfix            # fast-track: release-captain only, skip style issues
+```
+
+## Report Format
+
+```
+## PRE-RELEASE REPORT
+
+### Release Readiness (release-captain)
+SEMVER:    [correct / incorrect]
+CHANGELOG: [complete / missing entries]
+ROLLBACK:  [plan exists / missing]
+SMOKE:     [covered / gaps]
+
+### Security Clearance (security-reviewer)
+CRITICAL: [list — block if any]
+HIGH:     [list]
+
+### Code Quality (code-reviewer)
+CRITICAL: [list — block if any]
+HIGH:     [list]
+
+---
+VERDICT: SHIP / FIX CRITICAL FIRST / BLOCK
+```
+
+## When to Use
+
+- Before cutting any release tag
+- Before merging a large feature branch
+- Before a hotfix deploy under pressure
+- As the final gate before `npm publish` or production push
+
+## Execute Now
+
+Invoking this command is confirmation to proceed. Execute immediately:
+
+1. Determine target from `$ARGUMENTS` (version tag, branch, or current state).
+2. Spawn all agents simultaneously with `run_in_background: true`:
+   - `release-captain` — release ritual check: semver, changelog, rollback
+   - `security-reviewer` — security clearance scan
+   - `code-reviewer` — final quality gate
+3. Wait for all to complete.
+4. Aggregate into the Pre-Release Report format above with a clear SHIP / BLOCK verdict.
+5. End with: "Ready to proceed with the release?" or list what must be fixed first.

package/commands/refactor-sprint.md

@@ -0,0 +1,77 @@
+---
+description: Parallel refactor sprint — fires refactor-cleaner + code-simplifier + type-design-analyzer + tdd-guide simultaneously. Full cleanup in one pass.
+---
+
+# /refactor-sprint — Parallel Refactor Sprint
+
+Four agents clean, simplify, type-harden, and test-cover your code simultaneously. What would take a full day of careful manual work is scoped and planned in 15 minutes.
+
+## What Gets Launched in Parallel
+
+| Agent | Focus |
+|---|---|
+| `refactor-cleaner` | Dead code, unused imports, duplicate logic, copy-paste debt, tech debt |
+| `code-simplifier` | Complex functions, deep nesting, clever one-liners, readability improvements |
+| `type-design-analyzer` | `any` types, weak discriminated unions, missing type guards, type safety gaps |
+| `tdd-guide` | Test coverage gaps, missing unit tests, untested edge cases, coverage below 80% |
+
+## Usage
+
+```
+/refactor-sprint                     # full repo
+/refactor-sprint src/auth/           # focus on a module
+/refactor-sprint --types-only        # skip cleanup, focus on type safety
+/refactor-sprint --tests-only        # skip cleanup, focus on test coverage
+```
+
+## Report Format
+
+```
+## REFACTOR SPRINT REPORT
+
+### Dead Code & Debt (refactor-cleaner)
+REMOVE:    [files, functions, imports to delete]
+EXTRACT:   [duplicated logic to consolidate]
+DEBT:      [tech debt items ranked by impact]
+
+### Simplification (code-simplifier)
+COMPLEX:   [functions that need splitting]
+NESTING:   [deep nesting to flatten with early returns]
+READABILITY: [naming and clarity improvements]
+
+### Type Safety (type-design-analyzer)
+ANY_USAGE: [locations using any/unknown unsafely]
+WEAK_TYPES:[discriminated unions to strengthen]
+GUARDS:    [missing type guards]
+
+### Test Coverage (tdd-guide)
+UNCOVERED: [critical paths with no tests]
+GAPS:      [edge cases missing]
+PLAN:      [test writing priority order]
+
+---
+TOTAL DEBT: X items | QUICK WINS: Y items
+RECOMMENDED ORDER: [prioritized action list]
+```
+
+## When to Use
+
+- Before a major feature addition (clean house first)
+- After a fast-moving sprint that accumulated debt
+- Monthly code health pass
+- Before onboarding a new team member
+- When coverage has dropped below 80%
+
+## Execute Now
+
+Invoking this command is confirmation to proceed. Execute immediately:
+
+1. Determine scope from `$ARGUMENTS`. Default: entire current project.
+2. Spawn all agents simultaneously with `run_in_background: true`:
+   - `refactor-cleaner` — dead code and duplicate logic audit
+   - `code-simplifier` — complexity and readability analysis
+   - `type-design-analyzer` — type safety audit
+   - `tdd-guide` — test coverage gap analysis
+3. Wait for all to complete.
+4. Aggregate into the Refactor Sprint Report above with a prioritized action list.
+5. End with: "Which area do you want to tackle first?"

package/commands/security-audit.md

@@ -0,0 +1,66 @@
+---
+description: Parallel security audit — fires security-reviewer + dependency-doctor + api-guardian simultaneously. Full threat surface in one command.
+---
+
+# /security-audit — Parallel Security Audit
+
+Three security-focused agents fire simultaneously. What would take an hour one-by-one finishes in 15 minutes.
+
+## What Gets Launched in Parallel
+
+| Agent | Focus |
+|---|---|
+| `security-reviewer` | OWASP Top 10, secrets in code, injection, XSS, CSRF, auth gaps, crypto misuse |
+| `dependency-doctor` | CVEs in deps, outdated packages, transitive vulnerabilities, license issues |
+| `api-guardian` | Exposed endpoints, missing auth, broken contracts, data leakage in responses |
+
+## Usage
+
+```
+/security-audit                  # full repo
+/security-audit src/auth/        # focus on auth module
+/security-audit --pre-deploy     # adds environment + secrets check
+```
+
+## Report Format
+
+```
+## SECURITY AUDIT REPORT
+
+### Vulnerabilities (security-reviewer)
+CRITICAL: [list]
+HIGH:     [list]
+MEDIUM:   [list]
+
+### Dependencies (dependency-doctor)
+CVE:      [list with severity]
+OUTDATED: [list]
+
+### API Surface (api-guardian)
+EXPOSED:  [list]
+WARN:     [list]
+
+---
+TOTAL: X critical, Y high, Z medium
+ACTION: [ship / patch first / block]
+```
+
+## When to Use
+
+- Before any production deploy
+- After adding new auth or payment flows
+- When a dep audit flags CVEs
+- Quarterly security health check
+
+## Execute Now
+
+Invoking this command is confirmation to proceed. Execute immediately:
+
+1. Determine scope from `$ARGUMENTS`. Default: entire current project.
+2. Spawn all agents simultaneously with `run_in_background: true`:
+   - `security-reviewer` — full OWASP scan of codebase
+   - `dependency-doctor` — CVE audit of all package manifests
+   - `api-guardian` — API surface exposure check
+3. Wait for all to complete.
+4. Aggregate into the Security Audit Report format above.
+5. End with: "Which vulnerability do you want to fix first?"

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}  61 specialist agents  ·  188 skills  ·  80 commands  ·  20+ hooks  ·  intent routing  ·  compound memory${RESET}"
+echo -e "${CYAN}  62 specialist agents  ·  188 skills  ·  88 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.4",
-  "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.5",
+  "description": "Production-grade AI coding toolkit — 62 agents, 188 skills, 88 commands, parallel multi-agent commands, semantic intent routing, self-learning memory. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
   "repository": {