| name | dev_invoke_kimi-cli |
| description | Legacy Claude-only provider orchestration for Opencode CLI using Kimi K2.5 via markdown file handoff.
Write test request to TASK.md, Opencode with Kimi K2.5 generates tests/reviews, outputs to OUTPUT.md.
Use only when the user explicitly requests Kimi or Opencode/Kimi. Do not trigger for
generic QAQC, testing, security review, edge case, or coverage requests.
Triggers: kimi, kimi k2.5, kimi cli, opencode kimi, kimisubagent,
togetherai kimi, opencode/kimi-k2.5-free, togetherai/moonshotai/Kimi-K2.5
Prerequisites: Opencode CLI installed, Together.ai API key (if using togetherai provider)
Models: opencode/kimi-k2.5-free (recommended), togetherai/moonshotai/Kimi-K2.5 (alternative)
|
| shared_corpus | false |
| harness_scope | claude_only |
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
| Model | Provider | Use Case | Status |
|---|
opencode/kimi-k2.5-free | Opencode (Moonshot) | Legacy explicit-request path; free tier | Verified |
opencode/kimi-k2.5 | Opencode (Moonshot) | Paid tier with higher rate limits | Available |
togetherai/moonshotai/Kimi-K2.5 | Together.ai | Alternative provider | Verified |
togetherai/moonshotai/Kimi-K2-5 | Together.ai | Alternative naming convention | Available |
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)
cd /path/to/project && opencode . -m opencode/kimi-k2.5-free
cd /path/to/project && opencode . -m togetherai/moonshotai/Kimi-K2.5
Piping Input (Most Reliable)
echo "Generate unit tests for the Calculator class" > prompt.txt
cat prompt.txt | opencode run -m opencode/kimi-k2.5-free
Core Flags Reference
| Flag | Purpose |
|---|
-m, --model | Model to use (e.g., opencode/kimi-k2.5-free) |
-C, --continue | Continue the last session |
-s, --session | Session ID to resume |
--prompt | Initial prompt to send |
-h, --help | Show help |
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
```typescript
// Paste code here
File: src/auth/validate.ts
Requirements
Test Requirements (if generating tests)
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:
```markdown
# 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
```typescript
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 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
```bash
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
MOONSHOT_API_KEY=xxx
TOGETHER_API_KEY=xxx
OPENAI_API_KEY=xxx
GEMINI_API_KEY=xxx
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 TOGETHER_API_KEY).
Rate Limits
Opencode (Moonshot AI)
| Limit | Value (Free Tier) |
|---|
| Requests/minute | 60 |
| Requests/day | 2,000 |
| Tokens/request | 128K context window |
Together.ai
| Limit | Value |
|---|
| Requests/minute | Varies by plan |
| Requests/day | Varies by plan |
| Tokens/request | 128K context window |
Note: Together.ai rate limits depend on your account tier. Check your Together.ai dashboard for current limits.
Quick Reference Table
| Provider | Model Path | API Key | Free Tier |
|---|
| Opencode | opencode/kimi-k2.5-free | Not needed* | 2,000 req/day |
| Opencode | opencode/kimi-k2.5 | Not needed* | Paid |
| Together.ai | togetherai/moonshotai/Kimi-K2.5 | TOGETHER_API_KEY | Varies |
*Opencode may use built-in credits or require authentication via opencode auth
Comparison, Tips, and Troubleshooting
Consult 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):
dev_invoke_codex-cli -- Alternative: Codex CLI for deep reasoningdev_invoke_gemini-cli -- Alternative: Gemini CLI for large contextqa_review_triple-model -- Uses this skill as one of three reviewers
