kodelyth-ecc 2.17.0 → 2.19.0

package/.aider-ecc/commands/plan.md

@@ -0,0 +1,117 @@
+---
+description: Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.
+---
+
+# Plan Command
+
+This command invokes the **planner** agent to create a comprehensive implementation plan before writing any code.
+
+## What This Command Does
+
+1. **Restate Requirements** - Clarify what needs to be built
+2. **Identify Risks** - Surface potential issues and blockers
+3. **Create Step Plan** - Break down implementation into phases
+4. **Wait for Confirmation** - MUST receive user approval before proceeding
+
+## When to Use
+
+Use `/plan` when:
+- Starting a new feature
+- Making significant architectural changes
+- Working on complex refactoring
+- Multiple files/components will be affected
+- Requirements are unclear or ambiguous
+
+## How It Works
+
+The planner agent will:
+
+1. **Analyze the request** and restate requirements in clear terms
+2. **Break down into phases** with specific, actionable steps
+3. **Identify dependencies** between components
+4. **Assess risks** and potential blockers
+5. **Estimate complexity** (High/Medium/Low)
+6. **Present the plan** and WAIT for your explicit confirmation
+
+## Example Usage
+
+```
+User: /plan I need to add real-time notifications when markets resolve
+
+Agent (planner):
+# Implementation Plan: Real-Time Market Resolution Notifications
+
+## Requirements Restatement
+- Send notifications to users when markets they're watching resolve
+- Support multiple notification channels (in-app, email, webhook)
+- Ensure notifications are delivered reliably
+- Include market outcome and user's position result
+
+## Implementation Phases
+
+### Phase 1: Database Schema
+- Add notifications table with columns: id, user_id, market_id, type, status, created_at
+- Add user_notification_preferences table for channel preferences
+- Create indexes on user_id and market_id for performance
+
+### Phase 2: Notification Service
+- Create notification service in lib/notifications.ts
+- Implement notification queue using BullMQ/Redis
+- Add retry logic for failed deliveries
+- Create notification templates
+
+### Phase 3: Integration Points
+- Hook into market resolution logic (when status changes to "resolved")
+- Query all users with positions in market
+- Enqueue notifications for each user
+
+### Phase 4: Frontend Components
+- Create NotificationBell component in header
+- Add NotificationList modal
+- Implement real-time updates via Supabase subscriptions
+- Add notification preferences page
+
+## Dependencies
+- Redis (for queue)
+- Email service (SendGrid/Resend)
+- Supabase real-time subscriptions
+
+## Risks
+- HIGH: Email deliverability (SPF/DKIM required)
+- MEDIUM: Performance with 1000+ users per market
+- MEDIUM: Notification spam if markets resolve frequently
+- LOW: Real-time subscription overhead
+
+## Estimated Complexity: MEDIUM
+- Backend: 4-6 hours
+- Frontend: 3-4 hours
+- Testing: 2-3 hours
+- Total: 9-13 hours
+
+**WAITING FOR CONFIRMATION**: Proceed with this plan? (yes/no/modify)
+```
+
+## Important Notes
+
+**CRITICAL**: The planner agent will **NOT** write any code until you explicitly confirm the plan with "yes" or "proceed" or similar affirmative response.
+
+If you want changes, respond with:
+- "modify: [your changes]"
+- "different approach: [alternative]"
+- "skip phase 2 and do phase 3 first"
+
+## Integration with Other Commands
+
+After planning:
+- Use `/tdd` to implement with test-driven development
+- Use `/build-fix` if build errors occur
+- Use `/code-review` to review completed implementation
+
+> **Need deeper planning?** Use `/prp-plan` for artifact-producing planning with PRD integration, codebase analysis, and pattern extraction. Use `/prp-implement` to execute those plans with rigorous validation loops.
+
+## Related Agents
+
+This command invokes the `planner` agent provided by ECC.
+
+For manual installs, the source file lives at:
+`agents/planner.md`

package/.aider-ecc/commands/pm2.md

@@ -0,0 +1,277 @@
+---
+description: Manage long-running dev processes with pm2 (start, stop, logs, status)
+argument-hint: "[action]"
+---
+
+# PM2 Init
+
+Auto-analyze project and generate PM2 service commands.
+
+**Command**: `$ARGUMENTS`
+
+---
+
+## Workflow
+
+1. Check PM2 (install via `npm install -g pm2` if missing)
+2. Scan project to identify services (frontend/backend/database)
+3. Generate config files and individual command files
+
+---
+
+## Service Detection
+
+| Type | Detection | Default Port |
+|------|-----------|--------------|
+| Vite | vite.config.* | 5173 |
+| Next.js | next.config.* | 3000 |
+| Nuxt | nuxt.config.* | 3000 |
+| CRA | react-scripts in package.json | 3000 |
+| Express/Node | server/backend/api directory + package.json | 3000 |
+| FastAPI/Flask | requirements.txt / pyproject.toml | 8000 |
+| Go | go.mod / main.go | 8080 |
+
+**Port Detection Priority**: User specified > .env > config file > scripts args > default port
+
+---
+
+## Generated Files
+
+```
+project/
+├── ecosystem.config.cjs              # PM2 config
+├── {backend}/start.cjs               # Python wrapper (if applicable)
+└── .claude/
+    ├── commands/
+    │   ├── pm2-all.md                # Start all + monit
+    │   ├── pm2-all-stop.md           # Stop all
+    │   ├── pm2-all-restart.md        # Restart all
+    │   ├── pm2-{port}.md             # Start single + logs
+    │   ├── pm2-{port}-stop.md        # Stop single
+    │   ├── pm2-{port}-restart.md     # Restart single
+    │   ├── pm2-logs.md               # View all logs
+    │   └── pm2-status.md             # View status
+    └── scripts/
+        ├── pm2-logs-{port}.ps1       # Single service logs
+        └── pm2-monit.ps1             # PM2 monitor
+```
+
+---
+
+## Windows Configuration (IMPORTANT)
+
+### ecosystem.config.cjs
+
+**Must use `.cjs` extension**
+
+```javascript
+module.exports = {
+  apps: [
+    // Node.js (Vite/Next/Nuxt)
+    {
+      name: 'project-3000',
+      cwd: './packages/web',
+      script: 'node_modules/vite/bin/vite.js',
+      args: '--port 3000',
+      interpreter: 'C:/Program Files/nodejs/node.exe',
+      env: { NODE_ENV: 'development' }
+    },
+    // Python
+    {
+      name: 'project-8000',
+      cwd: './backend',
+      script: 'start.cjs',
+      interpreter: 'C:/Program Files/nodejs/node.exe',
+      env: { PYTHONUNBUFFERED: '1' }
+    }
+  ]
+}
+```
+
+**Framework script paths:**
+
+| Framework | script | args |
+|-----------|--------|------|
+| Vite | `node_modules/vite/bin/vite.js` | `--port {port}` |
+| Next.js | `node_modules/next/dist/bin/next` | `dev -p {port}` |
+| Nuxt | `node_modules/nuxt/bin/nuxt.mjs` | `dev --port {port}` |
+| Express | `src/index.js` or `server.js` | - |
+
+### Python Wrapper Script (start.cjs)
+
+```javascript
+const { spawn } = require('child_process');
+const proc = spawn('python', ['-m', 'uvicorn', 'app.main:app', '--host', '0.0.0.0', '--port', '8000', '--reload'], {
+  cwd: __dirname, stdio: 'inherit', windowsHide: true
+});
+proc.on('close', (code) => process.exit(code));
+```
+
+---
+
+## Command File Templates (Minimal Content)
+
+### pm2-all.md (Start all + monit)
+````markdown
+Start all services and open PM2 monitor.
+```bash
+cd "{PROJECT_ROOT}" && pm2 start ecosystem.config.cjs && start wt.exe -d "{PROJECT_ROOT}" pwsh -NoExit -c "pm2 monit"
+```
+````
+
+### pm2-all-stop.md
+````markdown
+Stop all services.
+```bash
+cd "{PROJECT_ROOT}" && pm2 stop all
+```
+````
+
+### pm2-all-restart.md
+````markdown
+Restart all services.
+```bash
+cd "{PROJECT_ROOT}" && pm2 restart all
+```
+````
+
+### pm2-{port}.md (Start single + logs)
+````markdown
+Start {name} ({port}) and open logs.
+```bash
+cd "{PROJECT_ROOT}" && pm2 start ecosystem.config.cjs --only {name} && start wt.exe -d "{PROJECT_ROOT}" pwsh -NoExit -c "pm2 logs {name}"
+```
+````
+
+### pm2-{port}-stop.md
+````markdown
+Stop {name} ({port}).
+```bash
+cd "{PROJECT_ROOT}" && pm2 stop {name}
+```
+````
+
+### pm2-{port}-restart.md
+````markdown
+Restart {name} ({port}).
+```bash
+cd "{PROJECT_ROOT}" && pm2 restart {name}
+```
+````
+
+### pm2-logs.md
+````markdown
+View all PM2 logs.
+```bash
+cd "{PROJECT_ROOT}" && pm2 logs
+```
+````
+
+### pm2-status.md
+````markdown
+View PM2 status.
+```bash
+cd "{PROJECT_ROOT}" && pm2 status
+```
+````
+
+### PowerShell Scripts (pm2-logs-{port}.ps1)
+```powershell
+Set-Location "{PROJECT_ROOT}"
+pm2 logs {name}
+```
+
+### PowerShell Scripts (pm2-monit.ps1)
+```powershell
+Set-Location "{PROJECT_ROOT}"
+pm2 monit
+```
+
+---
+
+## Key Rules
+
+1. **Config file**: `ecosystem.config.cjs` (not .js)
+2. **Node.js**: Specify bin path directly + interpreter
+3. **Python**: Node.js wrapper script + `windowsHide: true`
+4. **Open new window**: `start wt.exe -d "{path}" pwsh -NoExit -c "command"`
+5. **Minimal content**: Each command file has only 1-2 lines description + bash block
+6. **Direct execution**: No AI parsing needed, just run the bash command
+
+---
+
+## Execute
+
+Based on `$ARGUMENTS`, execute init:
+
+1. Scan project for services
+2. Generate `ecosystem.config.cjs`
+3. Generate `{backend}/start.cjs` for Python services (if applicable)
+4. Generate command files in `.claude/commands/`
+5. Generate script files in `.claude/scripts/`
+6. **Update project CLAUDE.md** with PM2 info (see below)
+7. **Display completion summary** with terminal commands
+
+---
+
+## Post-Init: Update CLAUDE.md
+
+After generating files, append PM2 section to project's `CLAUDE.md` (create if not exists):
+
+````markdown
+## PM2 Services
+
+| Port | Name | Type |
+|------|------|------|
+| {port} | {name} | {type} |
+
+**Terminal Commands:**
+```bash
+pm2 start ecosystem.config.cjs   # First time
+pm2 start all                    # After first time
+pm2 stop all / pm2 restart all
+pm2 start {name} / pm2 stop {name}
+pm2 logs / pm2 status / pm2 monit
+pm2 save                         # Save process list
+pm2 resurrect                    # Restore saved list
+```
+````
+
+**Rules for CLAUDE.md update:**
+- If PM2 section exists, replace it
+- If not exists, append to end
+- Keep content minimal and essential
+
+---
+
+## Post-Init: Display Summary
+
+After all files generated, output:
+
+```
+## PM2 Init Complete
+
+**Services:**
+
+| Port | Name | Type |
+|------|------|------|
+| {port} | {name} | {type} |
+
+**Claude Commands:** /pm2-all, /pm2-all-stop, /pm2-{port}, /pm2-{port}-stop, /pm2-logs, /pm2-status
+
+**Terminal Commands:**
+## First time (with config file)
+pm2 start ecosystem.config.cjs && pm2 save
+
+## After first time (simplified)
+pm2 start all          # Start all
+pm2 stop all           # Stop all
+pm2 restart all        # Restart all
+pm2 start {name}       # Start single
+pm2 stop {name}        # Stop single
+pm2 logs               # View logs
+pm2 monit              # Monitor panel
+pm2 resurrect          # Restore saved processes
+
+**Tip:** Run `pm2 save` after first start to enable simplified commands.
+```

package/.aider-ecc/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/.aider-ecc/commands/project-launch.md

@@ -0,0 +1,91 @@
+---
+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
+
+---
+
+## Execute Now
+
+Invoking this command is confirmation to proceed. Do not show this documentation to the user — execute immediately:
+
+1. Read `$ARGUMENTS` for the project description. If empty, ask: "What are you building? Describe it in 2–3 sentences."
+2. Once you have a project description, spawn all agents simultaneously using `run_in_background: true`:
+   - `architect` — system design, tech selection, component breakdown
+   - `pair-programmer` — implementation approach, patterns, gotchas
+   - `security-reviewer` — threats, auth design, data exposure risks
+   - `tdd-guide` — test strategy, coverage plan, critical paths to test
+   - `ux-reviewer` — UX flows, accessibility, interaction design
+3. Wait for all agents to complete.
+4. Aggregate into the Project Launch Report format above.
+5. End with: "Which area do you want to go deeper on first?"

package/.aider-ecc/commands/projects.md

@@ -0,0 +1,39 @@
+---
+name: projects
+description: List known projects and their instinct statistics
+command: true
+---
+
+# Projects Command
+
+List project registry entries and per-project instinct/observation counts for continuous-learning-v2.
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" projects
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation):
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py projects
+```
+
+## Usage
+
+```bash
+/projects
+```
+
+## What to Do
+
+1. Read `~/.claude/homunculus/projects.json`
+2. For each project, display:
+   - Project name, id, root, remote
+   - Personal and inherited instinct counts
+   - Observation event count
+   - Last seen timestamp
+3. Also display global instinct totals

package/.aider-ecc/commands/promote.md

@@ -0,0 +1,41 @@
+---
+name: promote
+description: Promote project-scoped instincts to global scope
+command: true
+---
+
+# Promote Command
+
+Promote instincts from project scope to global scope in continuous-learning-v2.
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" promote [instinct-id] [--force] [--dry-run]
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation):
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py promote [instinct-id] [--force] [--dry-run]
+```
+
+## Usage
+
+```bash
+/promote                      # Auto-detect promotion candidates
+/promote --dry-run            # Preview auto-promotion candidates
+/promote --force              # Promote all qualified candidates without prompt
+/promote grep-before-edit     # Promote one specific instinct from current project
+```
+
+## What to Do
+
+1. Detect current project
+2. If `instinct-id` is provided, promote only that instinct (if present in current project)
+3. Otherwise, find cross-project candidates that:
+   - Appear in at least 2 projects
+   - Meet confidence threshold
+4. Write promoted instincts to `~/.claude/homunculus/instincts/personal/` with `scope: global`

package/.aider-ecc/commands/prompt-optimize.md

@@ -0,0 +1,23 @@
+---
+description: Legacy slash-entry shim for the prompt-optimizer skill. Prefer the skill directly.
+---
+
+# Prompt Optimize (Legacy Shim)
+
+Use this only if you still invoke `/prompt-optimize`. The maintained workflow lives in `skills/prompt-optimizer/SKILL.md`.
+
+## Canonical Surface
+
+- Prefer the `prompt-optimizer` skill directly.
+- Keep this file only as a compatibility entry point.
+
+## Arguments
+
+`$ARGUMENTS`
+
+## Delegation
+
+Apply the `prompt-optimizer` skill.
+- Keep it advisory-only: optimize the prompt, do not execute the task.
+- Return the recommended ECC components plus a ready-to-run prompt.
+- If the user actually wants direct execution, say so and tell them to make a normal task request instead of staying inside the shim.