oh-my-codex-cli 0.1.0

package/.agent/skills/e2e/SKILL.md

@@ -0,0 +1,396 @@
+---
+name: e2e
+description: Imported from everything-codex command e2e
+---
+
+---
+description: Generate and run end-to-end tests with Playwright. Creates test journeys, runs tests, captures screenshots/videos/traces, and uploads artifacts.
+---
+
+# E2E Command
+
+
+## Native Subagent Protocol (Codex)
+
+Codex supports native subagents. Delegate with `spawn_agent`, coordinate with `send_input`, collect via `wait`, and clean up with `close_agent`.
+
+Execution preference:
+1. Use native subagents first for independent workstreams (parallel when possible).
+2. Merge results in main thread and run final verification.
+3. Fallback only when delegation is blocked: use the `[ANALYST]`/`[ARCHITECT]`/`[EXECUTOR]`/`[REVIEWER]` structure in a single response.
+
+Minimal orchestration pattern:
+```text
+spawn_agent -> send_input (optional) -> wait -> close_agent
+```
+
+This command invokes the **e2e-runner** agent to generate, maintain, and execute end-to-end tests using Playwright.
+
+## What This Command Does
+
+1. **Generate Test Journeys** - Create Playwright tests for user flows
+2. **Run E2E Tests** - Execute tests across browsers
+3. **Capture Artifacts** - Screenshots, videos, traces on failures
+4. **Upload Results** - HTML reports and JUnit XML
+5. **Identify Flaky Tests** - Quarantine unstable tests
+
+## When to Use
+
+Use `$e2e` when:
+- Testing critical user journeys (login, trading, payments)
+- Verifying multi-step flows work end-to-end
+- Testing UI interactions and navigation
+- Validating integration between frontend and backend
+- Preparing for production deployment
+
+## Integration with `tdd` and `electron-driver`
+
+Use `$e2e` as the top-level E2E orchestrator:
+
+1. `$tdd` covers unit and integration tests first.
+2. `$e2e` covers cross-layer user journeys.
+3. If target is Electron desktop app, route execution to `$electron-driver` for runtime driving while keeping Playwright-style assertions and artifacts.
+
+Electron routing signals:
+- `electron` in package dependencies or scripts
+- desktop window flows, native menu, preload/IPC interactions
+- user explicitly asks for Electron app automation
+
+## How It Works
+
+The e2e-runner agent will:
+
+1. **Analyze user flow** and identify test scenarios
+2. **Generate Playwright test** using Page Object Model pattern
+3. **Run tests** across multiple browsers (Chrome, Firefox, Safari)
+4. **Capture failures** with screenshots, videos, and traces
+5. **Generate report** with results and artifacts
+6. **Identify flaky tests** and recommend fixes
+
+## Example Usage
+
+```
+User: $e2e Test the market search and view flow
+
+Agent (e2e-runner):
+# E2E Test Generation: Market Search and View Flow
+
+## Test Scenario Identified
+
+**User Journey:** Market Search → View Results → Click Market → View Details
+
+**Test Coverage:**
+1. Navigate to markets page
+2. Perform semantic search
+3. Verify search results
+4. Click on first result
+5. Verify market details page loads
+6. Verify chart renders
+
+## Generated Test Code
+
+```typescript
+// tests/e2e/markets/search-and-view.spec.ts
+import { test, expect } from '@playwright/test'
+import { MarketsPage } from '../../pages/MarketsPage'
+import { MarketDetailsPage } from '../../pages/MarketDetailsPage'
+
+test.describe('Market Search and View Flow', () => {
+  test('user can search markets and view details', async ({ page }) => {
+    // 1. Navigate to markets page
+    const marketsPage = new MarketsPage(page)
+    await marketsPage.goto()
+
+    // Verify page loaded
+    await expect(page).toHaveTitle(/Markets/)
+    await expect(page.locator('h1')).toContainText('Markets')
+
+    // 2. Perform semantic search
+    await marketsPage.searchMarkets('election')
+
+    // Wait for API response
+    await page.waitForResponse(resp =>
+      resp.url().includes('/api/markets/search') && resp.status() === 200
+    )
+
+    // 3. Verify search results
+    const marketCards = marketsPage.marketCards
+    await expect(marketCards.first()).toBeVisible()
+    const resultCount = await marketCards.count()
+    expect(resultCount).toBeGreaterThan(0)
+
+    // Take screenshot of search results
+    await page.screenshot({ path: 'artifacts/search-results.png' })
+
+    // 4. Click on first result
+    const firstMarketTitle = await marketCards.first().textContent()
+    await marketCards.first().click()
+
+    // 5. Verify market details page loads
+    await expect(page).toHaveURL(/\/markets\/[a-z0-9-]+/)
+
+    const detailsPage = new MarketDetailsPage(page)
+    await expect(detailsPage.marketName).toBeVisible()
+    await expect(detailsPage.marketDescription).toBeVisible()
+
+    // 6. Verify chart renders
+    await expect(detailsPage.priceChart).toBeVisible()
+
+    // Verify market name matches
+    const detailsTitle = await detailsPage.marketName.textContent()
+    expect(detailsTitle?.toLowerCase()).toContain(
+      firstMarketTitle?.toLowerCase().substring(0, 20) || ''
+    )
+
+    // Take screenshot of market details
+    await page.screenshot({ path: 'artifacts/market-details.png' })
+  })
+
+  test('search with no results shows empty state', async ({ page }) => {
+    const marketsPage = new MarketsPage(page)
+    await marketsPage.goto()
+
+    // Search for non-existent market
+    await marketsPage.searchMarkets('xyznonexistentmarket123456')
+
+    // Verify empty state
+    await expect(page.locator('[data-testid="no-results"]')).toBeVisible()
+    await expect(page.locator('[data-testid="no-results"]')).toContainText(
+      /no.*results|no.*markets/i
+    )
+
+    const marketCount = await marketsPage.marketCards.count()
+    expect(marketCount).toBe(0)
+  })
+
+  test('can clear search and see all markets again', async ({ page }) => {
+    const marketsPage = new MarketsPage(page)
+    await marketsPage.goto()
+
+    // Initial market count
+    const initialCount = await marketsPage.marketCards.count()
+
+    // Perform search
+    await marketsPage.searchMarkets('trump')
+    await page.waitForLoadState('networkidle')
+
+    // Verify filtered results
+    const filteredCount = await marketsPage.marketCards.count()
+    expect(filteredCount).toBeLessThan(initialCount)
+
+    // Clear search
+    await marketsPage.searchInput.clear()
+    await page.waitForLoadState('networkidle')
+
+    // Verify all markets shown again
+    const finalCount = await marketsPage.marketCards.count()
+    expect(finalCount).toBe(initialCount)
+  })
+})
+```
+
+## Running Tests
+
+```bash
+# Run the generated test
+npx playwright test tests/e2e/markets/search-and-view.spec.ts
+
+Running 3 tests using 3 workers
+
+  ✓  [chromium] › search-and-view.spec.ts:5:3 › user can search markets and view details (4.2s)
+  ✓  [chromium] › search-and-view.spec.ts:52:3 › search with no results shows empty state (1.8s)
+  ✓  [chromium] › search-and-view.spec.ts:67:3 › can clear search and see all markets again (2.9s)
+
+  3 passed (9.1s)
+
+Artifacts generated:
+- artifacts/search-results.png
+- artifacts/market-details.png
+- playwright-report/index.html
+```
+
+## Test Report
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║                    E2E Test Results                          ║
+╠══════════════════════════════════════════════════════════════╣
+║ Status:     ✅ ALL TESTS PASSED                              ║
+║ Total:      3 tests                                          ║
+║ Passed:     3 (100%)                                         ║
+║ Failed:     0                                                ║
+║ Flaky:      0                                                ║
+║ Duration:   9.1s                                             ║
+╚══════════════════════════════════════════════════════════════╝
+
+Artifacts:
+📸 Screenshots: 2 files
+📹 Videos: 0 files (only on failure)
+🔍 Traces: 0 files (only on failure)
+📊 HTML Report: playwright-report/index.html
+
+View report: npx playwright show-report
+```
+
+✅ E2E test suite ready for CI/CD integration!
+```
+
+## Test Artifacts
+
+When tests run, the following artifacts are captured:
+
+**On All Tests:**
+- HTML Report with timeline and results
+- JUnit XML for CI integration
+
+**On Failure Only:**
+- Screenshot of the failing state
+- Video recording of the test
+- Trace file for debugging (step-by-step replay)
+- Network logs
+- Console logs
+
+## Viewing Artifacts
+
+```bash
+# View HTML report in browser
+npx playwright show-report
+
+# View specific trace file
+npx playwright show-trace artifacts/trace-abc123.zip
+
+# Screenshots are saved in artifacts/ directory
+open artifacts/search-results.png
+```
+
+## Flaky Test Detection
+
+If a test fails intermittently:
+
+```
+⚠️  FLAKY TEST DETECTED: tests/e2e/markets/trade.spec.ts
+
+Test passed 7/10 runs (70% pass rate)
+
+Common failure:
+"Timeout waiting for element '[data-testid="confirm-btn"]'"
+
+Recommended fixes:
+1. Add explicit wait: await page.waitForSelector('[data-testid="confirm-btn"]')
+2. Increase timeout: { timeout: 10000 }
+3. Check for race conditions in component
+4. Verify element is not hidden by animation
+
+Quarantine recommendation: Mark as test.fixme() until fixed
+```
+
+## Browser Configuration
+
+Tests run on multiple browsers by default:
+- ✅ Chromium (Desktop Chrome)
+- ✅ Firefox (Desktop)
+- ✅ WebKit (Desktop Safari)
+- ✅ Mobile Chrome (optional)
+
+Configure in `playwright.config.ts` to adjust browsers.
+
+## CI/CD Integration
+
+Add to your CI pipeline:
+
+```yaml
+# .github/workflows/e2e.yml
+- name: Install Playwright
+  run: npx playwright install --with-deps
+
+- name: Run E2E tests
+  run: npx playwright test
+
+- name: Upload artifacts
+  if: always()
+  uses: actions/upload-artifact@v3
+  with:
+    name: playwright-report
+    path: playwright-report/
+```
+
+## PMX-Specific Critical Flows
+
+For PMX, prioritize these E2E tests:
+
+**🔴 CRITICAL (Must Always Pass):**
+1. User can connect wallet
+2. User can browse markets
+3. User can search markets (semantic search)
+4. User can view market details
+5. User can place trade (with test funds)
+6. Market resolves correctly
+7. User can withdraw funds
+
+**🟡 IMPORTANT:**
+1. Market creation flow
+2. User profile updates
+3. Real-time price updates
+4. Chart rendering
+5. Filter and sort markets
+6. Mobile responsive layout
+
+## Best Practices
+
+**DO:**
+- ✅ Use Page Object Model for maintainability
+- ✅ Use data-testid attributes for selectors
+- ✅ Wait for API responses, not arbitrary timeouts
+- ✅ Test critical user journeys end-to-end
+- ✅ Run tests before merging to main
+- ✅ Review artifacts when tests fail
+
+**DON'T:**
+- ❌ Use brittle selectors (CSS classes can change)
+- ❌ Test implementation details
+- ❌ Run tests against production
+- ❌ Ignore flaky tests
+- ❌ Skip artifact review on failures
+- ❌ Test every edge case with E2E (use unit tests)
+
+## Important Notes
+
+**CRITICAL for PMX:**
+- E2E tests involving real money MUST run on testnet/staging only
+- Never run trading tests against production
+- Set `test.skip(process.env.NODE_ENV === 'production')` for financial tests
+- Use test wallets with small test funds only
+
+## Integration with Other Commands
+
+- Use `$plan` to identify critical journeys to test
+- Use `$tdd` for unit tests (faster, more granular)
+- Use `$e2e` for integration and user journey tests
+- Use `$code-review` to verify test quality
+
+## Related Agents
+
+This command invokes the `e2e-runner` agent located at:
+`~/.codex/agents/e2e-runner.md` (if present)
+
+## Quick Commands
+
+```bash
+# Run all E2E tests
+npx playwright test
+
+# Run specific test file
+npx playwright test tests/e2e/markets/search.spec.ts
+
+# Run in headed mode (see browser)
+npx playwright test --headed
+
+# Debug test
+npx playwright test --debug
+
+# Generate test code
+npx playwright codegen http:/$localhost:3000
+
+# View report
+npx playwright show-report
+```

package/.agent/skills/ecomode/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: ecomode
+description: Token-efficient parallel execution mode using Haiku and Sonnet agents
+---
+
+# Ecomode Skill
+
+
+## Native Subagent Protocol (Codex)
+
+Codex supports native subagents. Delegate with `spawn_agent`, coordinate with `send_input`, collect via `wait`, and clean up with `close_agent`.
+
+Execution preference:
+1. Use native subagents first for independent workstreams (parallel when possible).
+2. Merge results in main thread and run final verification.
+3. Fallback only when delegation is blocked: use the `[ANALYST]`/`[ARCHITECT]`/`[EXECUTOR]`/`[REVIEWER]` structure in a single response.
+
+Minimal orchestration pattern:
+```text
+spawn_agent -> send_input (optional) -> wait -> close_agent
+```
+
+> Codex invocation: use `$ecomode ...` or `ecomode: ...`
+
+
+Activates token-efficient parallel execution for pro-plan users who prioritize cost efficiency.
+
+## When Activated
+
+This skill enhances Codex's capabilities by:
+
+1. **Parallel Execution**: Running multiple agents simultaneously for independent tasks
+2. **Token-Conscious Routing**: Preferring Haiku and Sonnet agents, avoiding Opus
+3. **Background Operations**: Using `run_in_background: true` for long operations
+4. **Persistence Enforcement**: Never stopping until all tasks are verified complete
+5. **Cost Optimization**: Minimizing token usage while maintaining quality
+
+## Ecomode Routing Rules (CRITICAL)
+
+**ALWAYS prefer lower tiers. Only escalate when task genuinely requires it.**
+
+| Decision | Rule |
+|----------|------|
+| DEFAULT | Use LOW tier (Haiku) for all tasks |
+| UPGRADE | Use MEDIUM (Sonnet) only when task complexity warrants |
+| AVOID | HIGH tier (Opus) - only use for planning/critique if explicitly essential |
+
+## Smart Model Routing (PREFER LOW TIER)
+
+**Choose tier based on task complexity: LOW (haiku) preferred → MEDIUM (sonnet) fallback → HIGH (opus) AVOID**
+
+### Agent Routing Table
+
+| Domain | PREFERRED (Haiku) | FALLBACK (Sonnet) | AVOID (Opus) |
+|--------|-------------------|-------------------|--------------|
+| **Analysis** | `architect-low` | `architect-medium` | ~~`architect`~~ |
+| **Execution** | `executor-low` | `executor` | ~~`executor-high`~~ |
+| **Search** | `explore` | `explore-medium` | ~~`explore-high`~~ |
+| **Research** | `researcher-low` | `researcher` | - |
+| **Frontend** | `designer-low` | `designer` | ~~`designer-high`~~ |
+| **Docs** | `writer` | - | - |
+| **Visual** | - | `vision` | - |
+| **Planning** | - | - | `planner` (if essential) |
+| **Critique** | - | - | `critic` (if essential) |
+| **Testing** | - | `qa-tester` | ~~`qa-tester-high`~~ |
+| **Security** | `security-reviewer-low` | - | ~~`security-reviewer`~~ |
+| **Build** | `build-fixer-low` | `build-fixer` | - |
+| **TDD** | `tdd-guide-low` | `tdd-guide` | - |
+| **Code Review** | `code-reviewer-low` | - | ~~`code-reviewer`~~ |
+| **Data Science** | `scientist-low` | `scientist` | ~~`scientist-high`~~ |
+
+### Tier Selection Guide (Token-Conscious)
+
+| Task Complexity | Tier | Examples |
+|-----------------|------|----------|
+| Simple lookups | LOW | "What does this function return?", "Find where X is defined" |
+| Standard work | LOW first, MEDIUM if fails | "Add error handling", "Implement this feature" |
+| Complex analysis | MEDIUM | "Debug this issue", "Refactor this module" |
+| Planning only | HIGH (if essential) | "Design architecture for new system" |
+
+### Routing Examples
+
+**CRITICAL: Always pass `model` parameter explicitly - Codex does NOT auto-apply models from agent definitions!**
+
+```
+// Simple question -> LOW tier (DEFAULT)
+[ARCHITECT-LOW | haiku] "What does this function return?"
+
+// Standard implementation -> TRY LOW first
+[EXECUTOR-LOW | haiku] "Add validation to login form"
+
+// If LOW fails, escalate to MEDIUM
+[EXECUTOR | sonnet] "Add error handling to login"
+
+// File lookup -> ALWAYS LOW
+[EXPLORE-LOW | haiku] "Find where UserService is defined"
+
+// Only use MEDIUM for complex patterns
+[EXPLORE | sonnet] "Find all authentication patterns in the codebase"
+```
+
+## DELEGATION ENFORCEMENT (CRITICAL)
+
+**YOU ARE AN ORCHESTRATOR, NOT AN IMPLEMENTER.**
+
+| Action | YOU Do | DELEGATE |
+|--------|--------|----------|
+| Read files for context | ✓ | |
+| Track progress (TODO) | ✓ | |
+| Spawn parallel agents | ✓ | |
+| **ANY code change** | ✗ NEVER | executor-low/executor |
+| **UI work** | ✗ NEVER | designer-low/designer |
+| **Docs** | ✗ NEVER | writer |
+
+**Path Exception**: Only write to `.omc/`, `.codex/`, `CLAUDE.md`, `AGENTS.md`
+
+## Background Execution Rules
+
+**Run in Background** (set `run_in_background: true`):
+- Package installation: npm install, pip install, cargo build
+- Build processes: npm run build, make, tsc
+- Test suites: npm test, pytest, cargo test
+- Docker operations: docker build, docker pull
+
+**Run Blocking** (foreground):
+- Quick status checks: git status, ls, pwd
+- File reads (NOT edits - delegate edits to executor-low)
+- Simple commands
+
+## Verification Checklist
+
+Before stopping, verify:
+- [ ] TODO LIST: Zero pending/in_progress tasks
+- [ ] FUNCTIONALITY: All requested features work
+- [ ] TESTS: All tests pass (if applicable)
+- [ ] ERRORS: Zero unaddressed errors
+
+**If ANY checkbox is unchecked, CONTINUE WORKING.**
+
+## Token Savings Tips
+
+1. **Batch similar tasks** to one agent instead of spawning many
+2. **Use explore (haiku)** for file discovery, not architect
+3. **Prefer executor-low** for simple changes - only upgrade if it fails
+4. **Avoid opus agents** unless the task genuinely requires deep reasoning
+5. **Use writer (haiku)** for all documentation tasks
+
+## STATE CLEANUP ON COMPLETION
+
+**IMPORTANT: Delete state files on completion - do NOT just set `active: false`**
+
+When ecomode completes (all verification passes):
+
+```bash
+# Delete ecomode state files
+rm -f .omc/state/ecomode-state.json
+rm -f ~/.codex/ecomode-state.json
+```
+
+This ensures clean state for future sessions. Stale state files with `active: false` should not be left behind.

package/.agent/skills/electron-driver/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: electron-driver
+description: E2E Testing & Automation for Electron Apps (Playwright)
+model: sonnet
+---
+
+# Electron Driver Skill
+
+**The standard tool for End-to-End (E2E) Verification of Electron Applications.**
+
+Use this skill when you need to:
+- **Verify UI functionality** (clicking buttons, checking text, form submission).
+- **Run automated regression tests** on a packaged or local Electron app.
+- **Drive the application** to reproduce bugs or set up state.
+- **Inspect** the DOM and console of a running Electron process.
+
+Supports two robust modes: **Launch** (Clean E2E Test) and **Attach** (Live Debugging).
+
+- **Launch**: Start a new Electron instance with a controlled environment.
+- **Attach**: Connect to an existing process via CDP (requires `--remote-debugging-port`).
+- **Inspect**: Smartly find the main window (ignoring DevTools).
+- **Interact**: Click, type, and verify using modern Playwright Locators.
+
+## Integration with `e2e` and `tdd`
+
+`electron-driver` is the Electron-specific execution backend in the testing stack:
+
+1. `$tdd` validates core logic and IPC units first.
+2. `$e2e` defines end-user journey scenarios.
+3. `$electron-driver` executes those scenarios against real Electron runtime windows/processes.
+
+Use this skill when `$e2e` detects Electron context or when desktop-runtime debugging is required.
+
+## Prerequisites
+
+1.  **Playwright**: `npm install playwright-core` (locally preferred) or `npm install -g playwright-core`.
+2.  **Electron Executable**:
+    - For **Launch**: Path to the Electron executable (e.g., `node_modules/.bin/electron` or the packaged app).
+    - For **Attach**: The target app MUST be running with `--remote-debugging-port=<port>`.
+
+## Strategy Selection
+
+| Mode | Use Case | Pros | Cons |
+|------|----------|------|------|
+| **Launch** | Automated tests, reproducible tasks | Clean env, no port conflicts, auto-close | Slower start, loses current app state |
+| **Attach** | Debugging current session, "Drive my app" | Preserves state, instant feedback | Complex setup (ports), fragile |
+
+## Usage
+
+### 1. Launch Mode (Recommended)
+
+Create a script that launches the app.
+
+**File:** `test-driver.cjs` (Use `.cjs` to avoid ESM/CJS issues)
+```javascript
+const { _electron: electron } = require('playwright-core');
+
+(async () => {
+  // Launch the app
+  // args: pointing to main.js or the packaged app executable
+  const app = await electron.launch({
+    args: ['.'], // Or path to executable
+    env: { ...process.env, NODE_ENV: 'development' }
+  });
+
+  try {
+    // Smart Window Find (ignoring DevTools)
+    const page = await app.firstWindow();
+    if (page.url().startsWith('devtools://')) {
+       // Loop to find real window if first one is devtools
+       // (Logic typically handled by waiting for first non-devtools window)
+    }
+    
+    console.log(`Title: ${await page.title()}`);
+
+    // --- ACTION LOGIC ---
+    // Modern Locator API
+    await page.getByRole('button', { name: 'Login' }).click();
+    await expect(page.getByText('Welcome')).toBeVisible(); // requires @playwright/test runner or stand-alone expect
+    
+    // Simple wait (if not using expect)
+    await page.locator('.status').waitFor();
+    // --------------------
+
+  } catch (err) {
+    console.error(err);
+  } finally {
+    // Close app
+    await app.close();
+  }
+})();
+```
+
+### 2. Attach Mode (Debugging)
+
+**Pre-check**: Ensure app is running with `--remote-debugging-port=9222` (or check console for actual port).
+
+**File:** `attach-driver.cjs`
+```javascript
+const { chromium } = require('playwright-core');
+
+(async () => {
+  try {
+    // Connect to CDP
+    const browser = await chromium.connectOverCDP('http://localhost:9222');
+    
+    // Find the right page (Filter out DevTools)
+    const context = browser.contexts()[0];
+    const pages = context.pages();
+    const page = pages.find(p => !p.url().startsWith('devtools://'));
+
+    if (!page) throw new Error('No valid app window found');
+
+    // --- ACTION LOGIC ---
+    await page.locator('#submit-btn').click();
+    // --------------------
+
+    await browser.close(); // Disconnects (does not kill app)
+  } catch (e) {
+    console.error(e);
+  }
+})();
+```
+
+## Playwright Modern Cheatsheet
+
+- **Locators (Preferred)**:
+    - `page.getByRole('button', { name: 'Save' })`
+    - `page.getByText('Hello World')`
+    - `page.getByPlaceholder('Email')`
+    - `page.locator('.css-class')`
+- **Actions**:
+    - `await locator.click()`
+    - `await locator.fill('text')`
+- **Waiting**:
+    - ❌ `await page.waitForSelector(...)` (Old)
+    - ✅ `await locator.waitFor()` (Explicit)
+    - ✅ `await locator.click()` (Auto-waits)
+
+## Troubleshooting
+
+- **ESM Error**: `SyntaxError: Cannot use import statement...` -> Save file as `.mjs` or change project type. **Recommendation**: Always save temp scripts as `.cjs` and use `require`.
+- **DevTools Window**: If the script interacts with the inspector instead of the app, check the window filtering logic.
+- **Port Conflict**: If 9222 is busy, try a different port in Launch args or Attach URL.