Invoking Kimi CLI (via Opencode)

Legacy Claude-only orchestration skill. This is not part of the standard production harness policy. It is excluded from the shared multi-harness corpus and should be used only when the user explicitly requests Kimi or Opencode/Kimi.

When the user explicitly requests Kimi or Opencode/Kimi, delegate the requested testing, quality assurance, or code review task to Opencode CLI using the Kimi K2.5 model. Write task instructions to TASK.md, invoke Opencode with Kimi K2.5, then read OUTPUT.md for results.

Pattern: Markdown File Handoff

Claude Code                         Opencode CLI + Kimi K2.5
    |                                   |
    +-- Write TASK.md ------------------+
    |   (test/review requirements)      |
    |                                   |
    +-- Execute: opencode run -m        |
    |   opencode/kimi-k2.5-free         |
    |   "Read TASK.md..."               |
    |                                   |
    |                                   +-- Reads TASK.md
    |                                   +-- Generates tests/review
    |                                   +-- Writes OUTPUT.md
    |                                   |
    +-- Read OUTPUT.md <----------------+
    |   (tests + findings + results)    |
    v                                   v

Benefits:

• Eliminates shell escaping issues
• Keeps context structured in reviewable files
• Enforces explicit output structure
• Supports both Opencode and Together.ai providers
• Excels at edge case detection

Legacy Model Selection

Codex is the production-supported second harness for this repository. Use this legacy Kimi path only when the user explicitly asks for Kimi or Opencode/Kimi.

Available Models

Default within this explicit legacy skill: opencode/kimi-k2.5-free.

Kimi K2.5 is kept here for historical workflows that specifically require it:

• Identifying edge cases and boundary conditions
• Generating comprehensive test scenarios
• Analyzing code for quality issues
• Providing thorough code reviews

Provider Selection Guide

Choose Opencode (opencode/kimi-k2.5-free) when:

• The user explicitly requested Kimi or Opencode/Kimi
• You want a free tier with generous limits (2,000 req/day)
• You already have Opencode configured for this legacy workflow

Choose Together.ai (togetherai/moonshotai/Kimi-K2.5) when:

• The user explicitly requested Kimi through Together.ai
• You have existing Together.ai credits or API keys
• You need different rate limits or pricing

Invocation

Standard Pattern Within This Legacy Skill

opencode run -m opencode/kimi-k2.5-free \
  "Read TASK.md in the current directory. Follow the testing instructions. Write all results to OUTPUT.md."

Alternative: Together.ai Provider

opencode run -m togetherai/moonshotai/Kimi-K2.5 \
  "Read TASK.md in the current directory. Follow the testing instructions. Write all results to OUTPUT.md."

Interactive Mode (if run command has issues)

# Start opencode TUI with Kimi K2.5 (Opencode)
cd /path/to/project && opencode . -m opencode/kimi-k2.5-free

# Or with Together.ai
cd /path/to/project && opencode . -m togetherai/moonshotai/Kimi-K2.5

Piping Input (Most Reliable)

# Create a prompt file
echo "Generate unit tests for the Calculator class" > prompt.txt
cat prompt.txt | opencode run -m opencode/kimi-k2.5-free

Core Flags Reference

Task File Template (TASK.md)

# Task: [Test Generation / Code Review / QA]

## Objective
[Clear statement of testing/review goal]

### Examples:
- Generate unit tests for user authentication module
- Review payment processing code for security issues
- Create integration tests for API endpoints
- Perform QA verification of search functionality

## Code to Test/Review

### File: src/auth/login.ts

// Paste code here

### File: src/auth/validate.ts

// Paste supporting code

## Requirements

### Test Requirements (if generating tests)
- [ ] Cover all public methods/functions
- [ ] Include happy path scenarios
- [ ] Include error/edge cases
- [ ] Test boundary conditions
- [ ] Mock external dependencies
- [ ] Achieve >80% code coverage

### Review Criteria (if reviewing code)
Rate findings: CRITICAL | HIGH | MEDIUM | LOW

#### Security
- Input validation gaps
- Authentication/authorization issues
- Data exposure risks

#### Reliability
- Error handling coverage
- Race conditions
- Resource leaks

#### Maintainability
- Testability of code
- Code clarity
- Documentation

## Test Framework
- **Framework:** Jest / Mocha / Vitest / pytest / etc.
- **Location:** `tests/` or `__tests__/` directory
- **Naming:** `[filename].test.[ext]` or `[filename].spec.[ext]`

## Context
- [Any relevant background, constraints, or requirements]
- [Dependencies or integrations]
- [Performance requirements]
- [Compliance needs]

## Output Format

Write to OUTPUT.md:
- Summary of tests generated or review findings
- Test scenarios/cases with descriptions
- File locations for generated tests
- Coverage analysis (if applicable)
- Issues found with severity ratings
- Recommendations for fixes
- Session ID for follow-up

Output File Template (OUTPUT.md)

Instruct Opencode with Kimi K2.5 to produce:

# Results: [Task Title]

## Summary
[Brief overview of what was accomplished]

## Generated Tests (if applicable)

### Test Files Created
| File | Description | Coverage |
|------|-------------|----------|
| `tests/auth/login.test.ts` | Unit tests for login | 95% |
| `tests/auth/validate.test.ts` | Validation tests | 88% |

### Test Scenarios

#### Happy Path
1. [Test case description]
   - Input: [example input]
   - Expected: [expected output]

#### Edge Cases
1. [Edge case description]
   - Input: [boundary value]
   - Expected: [expected behavior]

#### Error Cases
1. [Error scenario]
   - Input: [invalid input]
   - Expected: [error handling]

## Review Findings (if applicable)

| Severity | Location | Issue | Recommendation |
|----------|----------|-------|----------------|
| CRITICAL | login.ts:45 | SQL injection | Use parameterized queries |
| HIGH | auth.ts:23 | Missing rate limiting | Add rate limiter |
| MEDIUM | users.ts:78 | No input validation | Add Zod validation |
| LOW | utils.ts:12 | Magic number | Extract constant |

## Code Coverage Analysis
- **Overall:** 87%
- **Critical paths:** 95%
- **Uncovered lines:** [list of uncovered code sections]

## Issues Encountered
- [Any problems and resolutions]

## Recommendations
1. [Priority action items]
2. [Secondary improvements]
3. [Testing best practices to adopt]

## Session
Session ID: `<session_id>` (for follow-up)

Workflow Example

Example 1: Test Generation

1. Claude Code writes TASK.md

# Task: Generate Unit Tests for User Authentication

## Objective
Create comprehensive unit tests for the user authentication module covering login, registration, and password reset.

## Code to Test

### File: src/auth/auth.service.ts

export class AuthService { async login(email: string, password: string): Promise<AuthResult> { const user = await this.userRepo.findByEmail(email); if (!user) throw new UnauthorizedError('Invalid credentials');

const valid = await bcrypt.compare(password, user.passwordHash); if (!valid) throw new UnauthorizedError('Invalid credentials');

const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET); return { token, user: this.sanitizeUser(user) }; }

async register(email: string, password: string): Promise<User> { const existing = await this.userRepo.findByEmail(email); if (existing) throw new ConflictError('Email already exists');

const hash = await bcrypt.hash(password, 10); return this.userRepo.create({ email, passwordHash: hash }); } }

## Requirements

### Test Requirements
- [ ] Test successful login with valid credentials
- [ ] Test login failure with invalid email
- [ ] Test login failure with wrong password
- [ ] Test successful registration
- [ ] Test registration with existing email
- [ ] Test JWT token generation
- [ ] Mock database repository
- [ ] Mock bcrypt and jwt

## Test Framework
- **Framework:** Jest
- **Location:** `tests/auth/`
- **Mocking:** jest.mock()

## Context
- Application uses TypeScript
- JWT tokens expire in 24 hours
- Passwords must be hashed with bcrypt (10 rounds)
- Database is PostgreSQL via TypeORM

## Output Format
Write to OUTPUT.md with test scenarios, generated test code, coverage analysis, and any edge cases identified.

2. Execute Opencode with Kimi K2.5

opencode run -m opencode/kimi-k2.5-free \
  "Read TASK.md in the current directory. Follow the instructions to generate comprehensive unit tests. Write all results to OUTPUT.md."

3. Claude Code reads OUTPUT.md

Review the generated tests, verify coverage, and integrate into the test suite.

Example 2: Code Review

1. Claude Code writes TASK.md

# Task: Security Review of Payment Processing

## Objective
Perform security-focused code review of payment processing module.

## Code to Review

### File: src/payments/payment.service.ts
[Code here...]

## Review Criteria
Rate findings: CRITICAL | HIGH | MEDIUM | LOW

### Security Focus
- Input validation
- SQL injection risks
- Authentication/authorization
- Sensitive data handling
- PCI compliance

## Context
- B2B SaaS application
- Handles credit card data
- SOC2 compliance required

## Output Format
Write security findings to OUTPUT.md with severity ratings and specific fix recommendations.

2. Execute Opencode with Kimi K2.5

opencode run -m opencode/kimi-k2.5-free \
  "Read TASK.md, perform security review following the criteria, write findings to OUTPUT.md"

3. Review Findings

Read OUTPUT.md and address the identified security issues.

Environment Variables

# For Opencode provider (Moonshot AI)
MOONSHOT_API_KEY=xxx      # Kimi models via Opencode (if needed)

# For Together.ai provider
TOGETHER_API_KEY=xxx      # Kimi models via Together.ai

# Alternative providers
OPENAI_API_KEY=xxx        # OpenAI models
GEMINI_API_KEY=xxx        # Google Gemini models

Note: Set the appropriate API key for your chosen provider. Opencode will use the key matching the model provider prefix (e.g., togetherai/* models need TOGETHERAPIKEY).

Rate Limits

Opencode (Moonshot AI)

Together.ai

Note: Together.ai rate limits depend on your account tier. Check your Together.ai dashboard for current limits.

Quick Reference Table

*Opencode may use built-in credits or require authentication via opencode auth

Comparison, Tips, and Troubleshooting

Consult [references/comparison-and-troubleshooting.md](references/comparison-and-troubleshooting.md) for model comparison (Kimi vs Gemini vs Codex), integration patterns, usage tips, troubleshooting, and session management.

Cross-References

Skills (related workflows):

• devinvokecodex-cli -- Alternative: Codex CLI for deep reasoning
• devinvokegemini-cli -- Alternative: Gemini CLI for large context
• qareviewtriple-model -- Uses this skill as one of three reviewers