# Standard installation with TUI
npx lazycodex-ai install

# Fully autonomous setup without terminal UI
npx lazycodex-ai install --no-tui --codex-autonomous

npx --yes --package oh-my-openagent omo install --platform=codex

# Basic autonomous loop
$ulw-loop "refactor authentication module to use JWT"

# With explicit completion promise
$ulw-loop "add TypeScript strict mode to entire codebase" \
  --completion-promise="All .ts files pass tsc --strict with zero errors"

# Strategy options
$ulw-loop "optimize database queries" --strategy=reset
$ulw-loop "fix all linting errors" --strategy=continue

# Generate a plan
$ulw-plan "add real-time collaboration features"

# Creates: plans/<slug>.md
# Example: plans/add-real-time-collaboration-features.md

# Execute most recent plan
$start-work

# Execute specific plan
$start-work add-real-time-collaboration-features

# Use custom worktree
$start-work api-refactor --worktree ./feature-branch

/init-deep

project-root/
├── AGENTS.md                    # Top-level context
├── src/
│   ├── AGENTS.md               # Module-level guidance
│   ├── components/
│   │   └── AGENTS.md           # Component patterns
│   └── utils/
│       └── AGENTS.md           # Utility conventions

# Project: E-commerce Platform

## Architecture
- Next.js 15 app router
- Prisma ORM with PostgreSQL
- tRPC for type-safe API

## Key Landmarks
- `/src/server/api/routers/` - tRPC route definitions
- `/src/components/ui/` - Radix UI + Tailwind components
- `/prisma/schema.prisma` - Database schema source of truth

## Agent Guidance
- Always run `pnpm db:push` after schema changes
- UI components use `cn()` utility for Tailwind merging
- API routes require auth middleware from `@/server/auth`

# Step 1: Strategic planning
$ulw-plan "add WebSocket support for real-time notifications"

# Creates: plans/add-websocket-support-for-real-time-notifications.md
# Review the plan, adjust if needed

# Step 2: Execute the plan
$start-work add-websocket-support-for-real-time-notifications

# Agent orchestrates:
# - Sisyphus: Coordination
# - Hephaestus: Implementation
# - Oracle: Verification
# - Librarian: Documentation

# Outputs: **ORCHESTRATION COMPLETE**

# Self-healing loop with evidence-based completion
$ulw-loop "fix failing integration tests in payment module" \
  --completion-promise="npm test -- payment.test.ts exits 0"

# Agent loop:
# 1. Run tests, capture failures
# 2. Analyze root cause
# 3. Implement fix
# 4. Verify with Oracle
# 5. Repeat until promise satisfied

# Step 1: Initialize project memory
/init-deep

# Step 2: Plan the refactor with context
$ulw-plan "migrate from REST to tRPC across all API routes"

# Step 3: Execute with checkpoints
$start-work migrate-from-rest-to-trpc

# Boulder progress tracking allows resumption if interrupted

// skills/custom-skill.ts
import { defineSkill } from 'oh-my-openagent';

export default defineSkill({
  name: 'api-testing',
  description: 'Generate and run API integration tests',
  
  triggers: [
    'test the API endpoints',
    'add integration tests',
    'verify API contracts'
  ],
  
  async execute(context) {
    const { projectPath, taskDescription } = context;
    
    // Analyze API routes
    const routes = await this.analyzeRoutes(projectPath);
    
    // Generate test files
    for (const route of routes) {
      await this.generateTest(route);
    }
    
    // Run tests with Oracle verification
    const result = await this.runTests();
    return result;
  }
});

// hooks/pre-commit-check.ts
import { defineHook } from 'oh-my-openagent';

export default defineHook({
  lifecycle: 'pre-commit',
  
  async run(context) {
    const { files } = context;
    
    // Run linter on changed files
    const lintResult = await exec('eslint', files);
    
    if (lintResult.exitCode !== 0) {
      throw new Error('Linting failed. Fix errors before committing.');
    }
    
    // Type check
    const tscResult = await exec('tsc', ['--noEmit']);
    
    if (tscResult.exitCode !== 0) {
      throw new Error('Type errors detected.');
    }
    
    return { success: true };
  }
});

// config/model-routing.ts
import { defineModelRouting } from 'oh-my-openagent';

export default defineModelRouting({
  categories: {
    'quick-edit': {
      model: 'gpt-5.4-mini',
      reasoning: 'low'
    },
    'ultrabrain': {
      model: 'gpt-5.2',
      reasoning: 'xhigh'
    },
    'agentic-coding': {
      model: 'gpt-5.3-codex',
      reasoning: 'high'
    }
  },
  
  fallbackChain: [
    'gpt-5.3-codex',
    'gpt-5.2',
    'gpt-5.4-mini'
  ]
});

{
  "agents": {
    "sisyphus": {
      "maxIterations": 500,
      "strategy": "continue"
    },
    "oracle": {
      "verificationStrict": true
    }
  },
  "skills": {
    "enabled": [
      "review-work",
      "programming",
      "LSP",
      "frontend-ui-ux"
    ],
    "disabled": ["remove-ai-slops"]
  },
  "models": {
    "defaultProvider": "openai",
    "routing": {
      "preferCodingModels": true
    }
  },
  "hooks": {
    "preCommit": true,
    "postPlan": false
  }
}

# OpenAI API configuration
export OPENAI_API_KEY=your_openai_api_key_here
export OPENAI_API_BASE=https://api.openai.com/v1  # Optional custom endpoint

# Model preferences
export OMO_DEFAULT_MODEL=gpt-5.3-codex
export OMO_REASONING_LEVEL=high  # low, medium, high, xhigh

# Agent behavior
export OMO_MAX_ITERATIONS=500
export OMO_STRATEGY=continue  # continue or reset

# Debugging
export OMO_DEBUG=true
export OMO_LOG_LEVEL=verbose

# Check which model handled each subtask
cat .lazycodex/logs/execution.log | grep "model="

# Make completion promise more specific
$ulw-loop "fix tests" \
  --completion-promise="npm test exits with code 0 AND coverage > 80%"

# Use reset strategy to clear context
$ulw-loop "refactor auth" --strategy=reset

# Check Oracle logs
cat .lazycodex/logs/oracle.log

# List available plans
ls plans/

# Specify plan explicitly with correct slug
$start-work add-websocket-support  # Not add-websocket-support.md

# Check plan file has valid checkbox syntax
# ✓ - [ ] Task description (not [x] or other formats)

# Force specific model for testing
export OMO_DEFAULT_MODEL=gpt-5.4-mini

# Disable auto-routing temporarily
export OMO_DISABLE_ROUTING=true

# Check model requirements
cat src/packages/model-core/src/model-requirements.ts

# Ensure sufficient directory depth
# /init-deep only creates AGENTS.md for complex directories

# Check scoring threshold
export OMO_COMPLEXITY_THRESHOLD=3  # Lower = more AGENTS.md files

# Run with verbose logging
export OMO_DEBUG=true
/init-deep

# Check skill is enabled
cat .lazycodex/config.json | grep -A 5 "skills"

# Explicit skill invocation
$ulw-loop "optimize queries" --skills=programming,LSP

# Verify skill triggers match your phrasing
cat skills/<skill-name>.md | grep "triggers:"

// Launch multiple agents for independent subtasks
import { orchestrate } from 'oh-my-openagent';

await orchestrate({
  parallel: true,
  tasks: [
    { agent: 'hephaestus', work: 'implement API routes' },
    { agent: 'hephaestus', work: 'create UI components' },
    { agent: 'librarian', work: 'update documentation' }
  ]
});

// Define Oracle completion criteria
import { defineVerification } from 'oh-my-openagent';

export default defineVerification({
  name: 'test-coverage-threshold',
  
  async verify(context) {
    const coverage = await getCoverage();
    
    return {
      passed: coverage.total > 80,
      evidence: `Total coverage: ${coverage.total}%`,
      nextSteps: coverage.total <= 80 
        ? ['Add tests for uncovered branches']
        : []
    };
  }
});

# Start with basic implementation
$ulw-plan "add dark mode toggle"
$start-work add-dark-mode-toggle

# Enhance with polish skill
$ulw-loop "polish dark mode UX" --skills=frontend-ui-ux

# Final cleanup
$ulw-loop "remove any AI code patterns" --skills=remove-ai-slops