oh-my-codex-cli 0.1.0

package/.agent/skills/ultraqa/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: ultraqa
+description: QA cycling workflow - test, verify, fix, repeat until goal met
+---
+
+# UltraQA 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 `$ultraqa ...` or `ultraqa: ...`
+
+
+[ULTRAQA ACTIVATED - AUTONOMOUS QA CYCLING]
+
+## Overview
+
+You are now in **ULTRAQA** mode - an autonomous QA cycling workflow that runs until your quality goal is met.
+
+**Cycle**: qa-tester → architect verification → fix → repeat
+
+## Goal Parsing
+
+Parse the goal from arguments. Supported formats:
+
+| Invocation | Goal Type | What to Check |
+|------------|-----------|---------------|
+| `$ultraqa --tests` | tests | All test suites pass |
+| `$ultraqa --build` | build | Build succeeds with exit 0 |
+| `$ultraqa --lint` | lint | No lint errors |
+| `$ultraqa --typecheck` | typecheck | No TypeScript errors |
+| `$ultraqa --custom "pattern"` | custom | Custom success pattern in output |
+
+If no structured goal provided, interpret the argument as a custom goal.
+
+## Cycle Workflow
+
+### Cycle N (Max 5)
+
+1. **RUN QA**: Execute verification based on goal type
+   - `--tests`: Run `npm test` or equivalent
+   - `--build`: Run `npm run build` or equivalent
+   - `--lint`: Run `npm run lint` or equivalent
+   - `--typecheck`: Run `npm run typecheck` or `tsc --noEmit`
+   - `--custom`: Run appropriate command and check for pattern
+   - `--interactive`: Use qa-tester for interactive CLI/service testing:
+     ```
+     [QA-TESTER | sonnet] TEST:
+     Goal: [describe what to verify]
+     Service: [how to start]
+     Test cases: [specific scenarios to verify]
+     ```
+
+2. **CHECK RESULT**: Did the goal pass?
+   - **YES** → Exit with success message
+   - **NO** → Continue to step 3
+
+3. **ARCHITECT DIAGNOSIS**: Spawn architect to analyze failure
+   ```
+   [ARCHITECT | opus] DIAGNOSE FAILURE:
+   Goal: [goal type]
+   Output: [test/build output]
+   Provide root cause and specific fix recommendations.
+   ```
+
+4. **FIX ISSUES**: Apply architect's recommendations
+   ```
+   [EXECUTOR | sonnet] FIX:
+   Issue: [architect diagnosis]
+   Files: [affected files]
+   Apply the fix precisely as recommended.
+   ```
+
+5. **REPEAT**: Go back to step 1
+
+## Exit Conditions
+
+| Condition | Action |
+|-----------|--------|
+| **Goal Met** | Exit with success: "ULTRAQA COMPLETE: Goal met after N cycles" |
+| **Cycle 5 Reached** | Exit with diagnosis: "ULTRAQA STOPPED: Max cycles. Diagnosis: ..." |
+| **Same Failure 3x** | Exit early: "ULTRAQA STOPPED: Same failure detected 3 times. Root cause: ..." |
+| **Environment Error** | Exit: "ULTRAQA ERROR: [tmux/port/dependency issue]" |
+
+## Observability
+
+Output progress each cycle:
+```
+[ULTRAQA Cycle 1/5] Running tests...
+[ULTRAQA Cycle 1/5] FAILED - 3 tests failing
+[ULTRAQA Cycle 1/5] Architect diagnosing...
+[ULTRAQA Cycle 1/5] Fixing: auth.test.ts - missing mock
+[ULTRAQA Cycle 2/5] Running tests...
+[ULTRAQA Cycle 2/5] PASSED - All 47 tests pass
+[ULTRAQA COMPLETE] Goal met after 2 cycles
+```
+
+## State Tracking
+
+Track state in `.omc/ultraqa-state.json`:
+```json
+{
+  "active": true,
+  "goal_type": "tests",
+  "goal_pattern": null,
+  "cycle": 1,
+  "max_cycles": 5,
+  "failures": ["3 tests failing: auth.test.ts"],
+  "started_at": "2024-01-18T12:00:00Z",
+  "session_id": "uuid"
+}
+```
+
+## Cancellation
+
+User can cancel with `$cancel` which clears the state file.
+
+## Important Rules
+
+1. **PARALLEL when possible** - Run diagnosis while preparing potential fixes
+2. **TRACK failures** - Record each failure to detect patterns
+3. **EARLY EXIT on pattern** - 3x same failure = stop and surface
+4. **CLEAR OUTPUT** - User should always know current cycle and status
+5. **CLEAN UP** - Clear state file on completion or cancellation
+
+## STATE CLEANUP ON COMPLETION
+
+**IMPORTANT: Delete state files on completion - do NOT just set `active: false`**
+
+When goal is met OR max cycles reached OR exiting early:
+
+```bash
+# Delete ultraqa state file
+rm -f .omc/state/ultraqa-state.json
+```
+
+This ensures clean state for future sessions. Stale state files with `active: false` should not be left behind.
+
+---
+
+Begin ULTRAQA cycling now. Parse the goal and start cycle 1.

package/.agent/skills/ultrawork/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: ultrawork
+description: Activate maximum performance mode with parallel agent orchestration for high-throughput task completion
+---
+
+# Ultrawork 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 `$ultrawork ...` or `ultrawork: ...`
+
+
+Activates maximum performance mode with parallel agent orchestration.
+
+## When Activated
+
+This skill enhances Codex's capabilities by:
+
+1. **Parallel Execution**: Running multiple agents simultaneously for independent tasks
+2. **Aggressive Delegation**: Routing tasks to specialist agents immediately
+3. **Background Operations**: Using `run_in_background: true` for long operations
+4. **Persistence Enforcement**: Never stopping until all tasks are verified complete
+5. **Smart Model Routing**: Using tiered agents to save tokens
+
+## Smart Model Routing (CRITICAL - SAVE TOKENS)
+
+**Choose tier based on task complexity: LOW (haiku) → MEDIUM (sonnet) → HIGH (opus)**
+
+### Available Agents by Tier
+
+| Domain | LOW (Haiku) | MEDIUM (Sonnet) | HIGH (Opus) |
+|--------|-------------|-----------------|-------------|
+| **Analysis** | `architect-low` | `architect-medium` | `architect` |
+| **Execution** | `executor-low` | `executor` | `executor-high` |
+| **Search** | `explore` | `explore-medium` | - |
+| **Research** | `researcher-low` | `researcher` | - |
+| **Frontend** | `designer-low` | `designer` | `designer-high` |
+| **Docs** | `writer` | - | - |
+| **Visual** | - | `vision` | - |
+| **Planning** | - | - | `planner`, `critic`, `analyst` |
+| **Testing** | - | `qa-tester` | - |
+| **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` |
+
+### Tier Selection Guide
+
+| Task Complexity | Tier | Examples |
+|-----------------|------|----------|
+| Simple lookups | LOW | "What does this function return?", "Find where X is defined" |
+| Standard work | MEDIUM | "Add error handling", "Implement this feature" |
+| Complex analysis | HIGH | "Debug this race condition", "Refactor auth module across 5 files" |
+
+### Routing Examples
+
+**CRITICAL: Always pass `model` parameter explicitly - Codex does NOT auto-apply models from agent definitions!**
+
+```
+// Simple question → LOW tier (saves tokens!)
+[ARCHITECT-LOW | haiku] "What does this function return?"
+
+// Standard implementation → MEDIUM tier
+[EXECUTOR | sonnet] "Add error handling to login"
+
+// Complex refactoring → HIGH tier
+[EXECUTOR-HIGH | opus] "Refactor auth module using JWT across 5 files"
+
+// Quick file lookup → LOW tier
+[EXPLORE-LOW | haiku] "Find where UserService is defined"
+
+// Thorough search → MEDIUM tier
+[EXPLORE | sonnet] "Find all authentication patterns in the codebase"
+```
+
+## 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, edits
+- 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.**
+
+## STATE CLEANUP ON COMPLETION
+
+**IMPORTANT: Delete state files on completion - do NOT just set `active: false`**
+
+When all verification passes and work is complete:
+
+```bash
+# Delete ultrawork state files
+rm -f .omc/state/ultrawork-state.json
+rm -f ~/.codex/ultrawork-state.json
+```
+
+This ensures clean state for future sessions. Stale state files with `active: false` should not be left behind.

package/.agent/skills/update-codemaps/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: update-codemaps
+description: Imported from everything-codex command update-codemaps
+---
+
+# Update Codemaps
+
+
+## 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
+```
+
+Analyze the codebase structure and update architecture documentation:
+
+1. Scan all source files for imports, exports, and dependencies
+2. Generate token-lean codemaps in the following format:
+   - codemaps/architecture.md - Overall architecture
+   - codemaps/backend.md - Backend structure  
+   - codemaps/frontend.md - Frontend structure
+   - codemaps/data.md - Data models and schemas
+
+3. Calculate diff percentage from previous version
+4. If changes > 30%, request user approval before updating
+5. Add freshness timestamp to each codemap
+6. Save reports to .reports/codemap-diff.txt
+
+Use TypeScript/Node.js for analysis. Focus on high-level structure, not implementation details.
+

package/.agent/skills/update-docs/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: update-docs
+description: Imported from everything-codex command update-docs
+---
+
+# Update Documentation
+
+
+## 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
+```
+
+Sync documentation from source-of-truth:
+
+1. Read package.json scripts section
+   - Generate scripts reference table
+   - Include descriptions from comments
+
+2. Read .env.example
+   - Extract all environment variables
+   - Document purpose and format
+
+3. Generate docs/CONTRIB.md with:
+   - Development workflow
+   - Available scripts
+   - Environment setup
+   - Testing procedures
+
+4. Generate docs/RUNBOOK.md with:
+   - Deployment procedures
+   - Monitoring and alerts
+   - Common issues and fixes
+   - Rollback procedures
+
+5. Identify obsolete documentation:
+   - Find docs not modified in 90+ days
+   - List for manual review
+
+6. Show diff summary
+
+Single source of truth: package.json and .env.example
+

package/.agent/skills/verification-loop/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: verification-loop
+description: Verification workflow with build/type/lint/test/security checks
+---
+
+# Verification Loop 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
+```
+
+A comprehensive verification system for Codex sessions.
+
+## When to Use
+
+Invoke this skill:
+- After completing a feature or significant code change
+- Before creating a PR
+- When you want to ensure quality gates pass
+- After refactoring
+
+## Verification Phases
+
+### Phase 1: Build Verification
+```bash
+# Check if project builds
+npm run build 2>&1 | tail -20
+# OR
+pnpm build 2>&1 | tail -20
+```
+
+If build fails, STOP and fix before continuing.
+
+### Phase 2: Type Check
+```bash
+# TypeScript projects
+npx tsc --noEmit 2>&1 | head -30
+
+# Python projects
+pyright . 2>&1 | head -30
+```
+
+Report all type errors. Fix critical ones before continuing.
+
+### Phase 3: Lint Check
+```bash
+# JavaScript/TypeScript
+npm run lint 2>&1 | head -30
+
+# Python
+ruff check . 2>&1 | head -30
+```
+
+### Phase 4: Test Suite
+```bash
+# Run tests with coverage
+npm run test -- --coverage 2>&1 | tail -50
+
+# Check coverage threshold
+# Target: 80% minimum
+```
+
+Report:
+- Total tests: X
+- Passed: X
+- Failed: X
+- Coverage: X%
+
+### Phase 5: Security Scan
+```bash
+# Check for secrets
+grep -rn "sk-" --include="*.ts" --include="*.js" . 2>/dev/null | head -10
+grep -rn "api_key" --include="*.ts" --include="*.js" . 2>/dev/null | head -10
+
+# Check for console.log
+grep -rn "console.log" --include="*.ts" --include="*.tsx" src/ 2>/dev/null | head -10
+```
+
+### Phase 6: Diff Review
+```bash
+# Show what changed
+git diff --stat
+git diff HEAD~1 --name-only
+```
+
+Review each changed file for:
+- Unintended changes
+- Missing error handling
+- Potential edge cases
+
+## Output Format
+
+After running all phases, produce a verification report:
+
+```
+VERIFICATION REPORT
+==================
+
+Build:     [PASS/FAIL]
+Types:     [PASS/FAIL] (X errors)
+Lint:      [PASS/FAIL] (X warnings)
+Tests:     [PASS/FAIL] (X/Y passed, Z% coverage)
+Security:  [PASS/FAIL] (X issues)
+Diff:      [X files changed]
+
+Overall:   [READY/NOT READY] for PR
+
+Issues to Fix:
+1. ...
+2. ...
+```
+
+## Continuous Mode
+
+For long sessions, run verification every 15 minutes or after major changes:
+
+```markdown
+Set a mental checkpoint:
+- After completing each function
+- After finishing a component
+- Before moving to next task
+
+Run: `$verify`
+```
+
+## Integration with Hooks
+
+This skill complements any available tool hooks but provides deeper verification.
+Hooks catch issues immediately; this skill provides comprehensive review.

package/.agent/skills/verify/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: verify
+description: Imported from everything-codex command verify
+---
+
+# Verification 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
+```
+
+Run comprehensive verification on current codebase state.
+
+## Instructions
+
+Execute verification in this exact order:
+
+1. **Build Check**
+   - Run the build command for this project
+   - If it fails, report errors and STOP
+
+2. **Type Check**
+   - Run TypeScript/type checker
+   - Report all errors with file:line
+
+3. **Lint Check**
+   - Run linter
+   - Report warnings and errors
+
+4. **Test Suite**
+   - Run all tests
+   - Report pass/fail count
+   - Report coverage percentage
+
+5. **Console.log Audit**
+   - Search for console.log in source files
+   - Report locations
+
+6. **Git Status**
+   - Show uncommitted changes
+   - Show files modified since last commit
+
+## Output
+
+Produce a concise verification report:
+
+```
+VERIFICATION: [PASS/FAIL]
+
+Build:    [OK/FAIL]
+Types:    [OK/X errors]
+Lint:     [OK/X issues]
+Tests:    [X/Y passed, Z% coverage]
+Secrets:  [OK/X found]
+Logs:     [OK/X console.logs]
+
+Ready for PR: [YES/NO]
+```
+
+If any critical issues, list them with fix suggestions.
+
+## Arguments
+
+$ARGUMENTS can be:
+- `quick` - Only build + types
+- `full` - All checks (default)
+- `pre-commit` - Checks relevant for commits
+- `pre-pr` - Full checks plus security scan
+