/auto-review-loop-minimax

name: auto-review-loop-minimax
description: Autonomous multi-round research review loop using MiniMax API. Use when you want to use MiniMax instead of Codex MCP for external review. Trigger with "auto review loop minimax" or "minimax review".
argument-hint: "[topic-or-scope]"
allowed-tools: Bash(*), Read, Grep, Glob, Write, Edit, Skill

Auto Review Loop (MiniMax Version): Autonomous Research Improvement

> 🔒 **Do not wrap this skill in `/loop`, `/schedule`, or `CronCreate`.** Like > `/auto-review-loop`, it already loops internally (review → fix → re-review), > feeding each round's prior-round summary into the next review prompt (the > backend is a stateless per-round API call, not a shared thread). An external > timer re-enters from the top each tick, dropping that accumulated context and > firing the verdict on wall-clock time instead of on artifact change — zero > new signal, full token cost. Schedule the *external wait that precedes it*, > not the verdict. See > [`shared-references/external-cadence.md`](../shared-references/external-cadence.md).

Autonomously iterate: review → implement fixes → re-review, until the external reviewer gives a positive assessment or MAX_ROUNDS is reached.

Context: $ARGUMENTS

Constants

• MAX_ROUNDS = 4
• POSITIVE_THRESHOLD: score >= 6/10 **AND** verdict ∈ {"ready", "almost"} — **both** must hold, matching the operative STOP CONDITION below. Verdict vocabulary is {"ready", "almost", "not ready"}. (Earlier wording used `or` and a stale verdict set; the `AND` form is authoritative.)
• REVIEW_DOC: `review-stage/AUTO_REVIEW.md` (cumulative log) *(fall back to `./AUTO_REVIEW.md` for legacy projects)*
• REVIEWER_MODEL = `MiniMax-M3` — Model used via MiniMax API

API Configuration

This skill uses MiniMax API for external review. Two methods are supported:

Method 1: MCP Tool (Primary)

If `mcp__minimax-chat__minimax_chat` is available, use it:

mcp__minimax-chat__minimax_chat:
  prompt: |
    [Review prompt content]
  model: "MiniMax-M3"
  system: "You are a senior machine learning researcher..."

Method 2: curl (Fallback)

If MCP is not available, use curl directly:

curl -s "https://api.minimax.io/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -d '{
    "model": "MiniMax-M3",
    "messages": [
      {"role": "system", "content": "You are a senior ML researcher..."},
      {"role": "user", "content": "[Review prompt]"}
    ],
    "max_tokens": 4096
  }'

**API Key**: Read from `~/.claude/settings.json` under `env.MINIMAX_API_KEY`, or from environment variable.

**Why MiniMax instead of Codex MCP?** Codex CLI uses OpenAI's Responses API (`/v1/responses`) which is not supported by third-party providers. See: https://github.com/openai/codex/discussions/7782

State Persistence (Compact Recovery)

Long-running loops may hit the context window limit, triggering automatic compaction. To survive this, persist state to `review-stage/REVIEW_STATE.json` after each round:

{
  "round": 2,
  "status": "in_progress",
  "last_score": 5.0,
  "last_verdict": "not ready",
  "pending_experiments": ["screen_name_1"],
  "timestamp": "2026-03-13T21:00:00"
}

**Write this file at the end of every Phase E** (after documenting the round). Overwrite each time — only the latest state matters.

**On completion** (positive assessment or max rounds), set `"status": "completed"` so future invocations don't accidentally resume a finished loop.

Workflow

Initialization

1. **Check for `review-stage/REVIEW_STATE.json`** *(fall back to `./REVIEW_STATE.json` if not found — legacy path)*:

• If neither path exists: **fresh start** (normal case)
• If it exists AND `status` is `"completed"`: **fresh start** (previous loop finished normally)
• If it exists AND `status` is `"in_progress"` AND `timestamp` is older than 24 hours: **fresh start** (stale state from a killed/abandoned run — delete the file and start over)
• If it exists AND `status` is `"in_progress"` AND `timestamp` is within 24 hours: **resume**
• Read the state file to recover `round`, `last_score`, `pending_experiments`
• Read `review-stage/AUTO_REVIEW.md` to restore full context of prior rounds *(fall back to `./AUTO_REVIEW.md`)*
• If `pending_experiments` is non-empty, check if they have completed (e.g., check screen sessions)
• Resume from the next round (round = saved round + 1)
• Log: "Recovered from context compaction. Resuming at Round N."

2. Read project narrative documents, memory files, and any prior review documents 3. Read recent experiment results (check output directories, logs) 4. Identify current weaknesses and open TODOs from prior reviews 5. Initialize round counter = 1 (unless recovered from state file) 6. Create/update `review-stage/AUTO_REVIEW.md` with header and timestamp

Loop (repeat up to MAX_ROUNDS)

Phase A: Review

Send comprehensive context to the external reviewer.

**Check MCP availability first**, then use appropriate method:

**If MCP available (Primary):**

Use mcp__minimax-chat__minimax_chat tool with:
- system: "You are a senior machine learning researcher serving as a reviewer for top-tier conferences like NeurIPS, ICML, and ICLR. Provide rigorous, constructive feedback."
- prompt: [Full review prompt with context]
- model: "MiniMax-M3"

**If MCP NOT available (Fallback):**

curl -s "https://api.minimax.io/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -d '{
    "model": "MiniMax-M3",
    "messages": [
      {
        "role": "system",
        "content": "You are a senior machine learning researcher serving as a reviewer for top-tier conferences like NeurIPS, ICML, and ICLR. Provide rigorous, constructive feedback."
      },
      {
        "role": "user",
        "content": "[Round N/MAX_ROUNDS of autonomous review loop]\n\n[Full research