@zephyrdeng/pi-review 0.7.1 → 0.8.0

package/extensions/rv-locale.ts

@@ -4,7 +4,23 @@ export type RvLocale = "en" | "zh";
 
 const CJK_RE = /[\u4e00-\u9fff\u3400-\u4dbf]/;
 
-export function detectRvLocale(textSamples: string[]): RvLocale {
+function systemPrefersZh(env: NodeJS.ProcessEnv = process.env): boolean {
+  const keys = ["LC_ALL", "LC_MESSAGES", "LANG", "LANGUAGE"];
+  for (const key of keys) {
+    const value = env[key];
+    if (!value) continue;
+    if (/(^|[_\.\-])zh/i.test(value)) return true;
+  }
+  return false;
+}
+
+/**
+ * Prefer Chinese when:
+ * - recent session text has meaningful CJK, or
+ * - system locale is zh and samples are empty/ambiguous.
+ * Re-run this on each completion; session_start-only capture freezes English too early.
+ */
+export function detectRvLocale(textSamples: string[], env: NodeJS.ProcessEnv = process.env): RvLocale {
   let cjk = 0;
   let latin = 0;
   for (const sample of textSamples) {
@@ -14,8 +30,10 @@ export function detectRvLocale(textSamples: string[]): RvLocale {
       else if (/[a-zA-Z]/.test(ch)) latin++;
     }
   }
-  if (cjk === 0 && latin === 0) return "en";
-  return cjk >= latin * 0.15 ? "zh" : "en";
+  if (cjk > 0 && cjk >= Math.max(1, latin * 0.05)) return "zh";
+  if (cjk === 0 && latin === 0) return systemPrefersZh(env) ? "zh" : "en";
+  if (systemPrefersZh(env) && cjk > 0) return "zh";
+  return "en";
 }
 
 export type RvUiStrings = {
@@ -32,6 +50,11 @@ export type RvUiStrings = {
   frontendPreset: string;
   planPreset: string;
   challengePreset: string;
+  loopCodePreset: string;
+  loopCodeDesc: string;
+  loopTwoRounds: string;
+  loopPlanPreset: string;
+  presetHint: string;
   suggested: string;
   presetTier: (n: number) => string;
   thinkingSuggested: string;
@@ -48,10 +71,15 @@ const UI: Record<RvLocale, RvUiStrings> = {
     keepSessionDesc: "Persist review session for /rv --continue",
     listModels: "list models",
     listModelsDesc: "Show provider/model catalog",
-    codePreset: "Code review (preset)",
-    frontendPreset: "Frontend / multimodal review (preset)",
-    planPreset: "Plan review (preset)",
-    challengePreset: "Challenge review (preset)",
+    codePreset: "Code review preset",
+    frontendPreset: "Frontend preset",
+    planPreset: "Plan review preset",
+    challengePreset: "Challenge preset",
+    loopCodePreset: "Loop closeout (code)",
+    loopCodeDesc: "Host fixes, re-review until clean",
+    loopTwoRounds: "Loop closeout (2 rounds)",
+    loopPlanPreset: "Loop closeout (plan)",
+    presetHint: "Type preset / code / plan for templates",
     suggested: "Suggested",
     presetTier: (n) => (n === 0 ? "Suggested" : `Preset #${n + 1}`),
     thinkingSuggested: "Suggested ",
@@ -66,10 +94,15 @@ const UI: Record<RvLocale, RvUiStrings> = {
     keepSessionDesc: "保留 review 会话，便于 /rv --continue",
     listModels: "查看模型列表",
     listModelsDesc: "列出当前可用 provider/model",
-    codePreset: "代码审核（推荐配置）",
-    frontendPreset: "前端 / 多模态审核（推荐）",
-    planPreset: "方案 / 架构审核（推荐）",
-    challengePreset: "对抗性方案审核（可追问）",
+    codePreset: "代码审核预设",
+    frontendPreset: "前端审核预设",
+    planPreset: "方案审核预设",
+    challengePreset: "对抗审核预设",
+    loopCodePreset: "Loop 关单（代码）",
+    loopCodeDesc: "宿主修 → 再审，直到 clean",
+    loopTwoRounds: "Loop 两轮关单",
+    loopPlanPreset: "Loop 关单（方案）",
+    presetHint: "输入 预设 / 代码 / 方案 查看模板",
     suggested: "推荐",
     presetTier: (n) => (n === 0 ? "推荐" : `预设 #${n + 1}`),
     thinkingSuggested: "推荐 ",

package/extensions/rv-model-picker.test.ts

@@ -0,0 +1,172 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { getKeybindings } from "@earendil-works/pi-tui";
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import type { ModelInfo } from "./rv-completions.js";
+import {
+  MODEL_PICKER_SKIP,
+  RvModelPickerComponent,
+  pickerProviders,
+  pickerRows,
+  type ModelPickerResult,
+} from "./rv-model-picker.js";
+
+// A fixture that mirrors the user's example: a `zenmux` provider with glm-5.2,
+// plus a couple of other providers so scope cycling and multi-token search are
+// meaningful. Ranking is driven by the caller (we pass already-ranked input).
+const ranked: ModelInfo[] = [
+  { provider: "anthropic", id: "claude-sonnet-4-5", label: "anthropic/claude-sonnet-4-5", name: "sonnet", reasoning: true, contextWindow: 200000, thinkingLevels: ["high", "xhigh"] },
+  { provider: "zenmux", id: "glm-5.2", label: "zenmux/glm-5.2", name: "glm", reasoning: true, contextWindow: 200000, thinkingLevels: ["high", "xhigh"] },
+  { provider: "zenmux", id: "glm-5.2-flash", label: "zenmux/glm-5.2-flash", name: "glm-flash", reasoning: true, contextWindow: 200000, thinkingLevels: ["high"] },
+  { provider: "openai", id: "gpt-5.6-luna", label: "openai/gpt-5.6-luna", name: "luna", reasoning: true, contextWindow: 200000, thinkingLevels: ["high", "xhigh"] },
+  { provider: "google", id: "gemini-3-pro", label: "google/gemini-3-pro", name: "pro", reasoning: true, contextWindow: 200000, thinkingLevels: ["high", "xhigh"] },
+];
+
+// Minimal fake TUI: the component only calls tui.requestRender().
+const fakeTui = { requestRender: () => {} } as unknown as Parameters<typeof RvModelPickerComponent.create>[0];
+const kb = getKeybindings() as KeybindingsManager;
+
+const theme = {
+  fg: (_c: string, t: string) => t,
+  bold: (t: string) => t,
+} as unknown as Parameters<typeof RvModelPickerComponent.create>[1];
+
+function makePicker(allowSkip: boolean, done: (r: ModelPickerResult) => void) {
+  return RvModelPickerComponent.create(fakeTui, theme, kb, done, {
+    locale: "en",
+    ranked,
+    allowSkip,
+    title: "Model",
+  });
+}
+
+function renderText(picker: RvModelPickerComponent, width = 80): string {
+  return picker.render(width).join("\n");
+}
+
+// Raw terminal bytes the real keybindings layer understands.
+const KEY = {
+  up: "\x1b[A",
+  down: "\x1b[B",
+  enter: "\r",
+  escape: "\x1b",
+  tab: "\t",
+  bs: "\x7f",
+};
+
+test("pickerRows prepends the skip row and preserves rank order", () => {
+  const withSkip = pickerRows(ranked, true);
+  assert.equal(withSkip[0].kind, "skip");
+  assert.deepEqual(
+    withSkip.slice(1).map((r) => (r.kind === "model" ? r.label : "")),
+    ranked.map((m) => m.label),
+  );
+
+  const noSkip = pickerRows(ranked, false);
+  assert.equal(noSkip[0].kind, "model");
+  assert.equal(noSkip.find((r) => r.kind === "skip"), undefined);
+});
+
+test("pickerProviders returns distinct providers in rank order", () => {
+  assert.deepEqual(pickerProviders(ranked), ["anthropic", "zenmux", "openai", "google"]);
+  assert.deepEqual(pickerProviders([ranked[1], ranked[3]]), ["zenmux", "openai"]);
+});
+
+test("typing filters the list live (single token)", () => {
+  const picker = makePicker(false, () => {});
+  picker.handleInput("g");
+  picker.handleInput("l");
+  picker.handleInput("m");
+  const out = renderText(picker);
+  // glm-5.2 and glm-5.2-flash both match; claude/gpt/gemini do not.
+  assert.ok(out.includes("glm-5.2"), out);
+  assert.ok(out.includes("glm-5.2-flash"), out);
+  assert.ok(!out.includes("claude-sonnet"), out);
+  assert.ok(!out.includes("gpt-5.6-luna"), out);
+});
+
+test("multi-token fuzzy search matches provider + model (zenmux glm)", () => {
+  const picker = makePicker(false, () => {});
+  for (const ch of "zenmux glm") picker.handleInput(ch);
+  const out = renderText(picker);
+  assert.ok(out.includes("glm-5.2"), out);
+  assert.ok(out.includes("glm-5.2-flash"), out);
+  // openai/gemini/anthropic excluded — different provider
+  assert.ok(!out.includes("gpt-5.6-luna"), out);
+  assert.ok(!out.includes("gemini-3-pro"), out);
+  assert.ok(!out.includes("claude-sonnet"), out);
+});
+
+test("no matches renders a no-match line", () => {
+  const picker = makePicker(false, () => {});
+  for (const ch of "zzzzz") picker.handleInput(ch);
+  const out = renderText(picker);
+  assert.ok(/No matching models/.test(out), out);
+});
+
+test("backspace edits the query and re-filters", () => {
+  const picker = makePicker(false, () => {});
+  for (const ch of "glm-5.2-") picker.handleInput(ch);
+  // typed "glm-5.2-" which matches only glm-5.2-flash (prefix); backspace -> "glm-5.2"
+  let out = renderText(picker);
+  assert.ok(out.includes("glm-5.2-flash"), out);
+  picker.handleInput(KEY.bs);
+  out = renderText(picker);
+  assert.ok(out.includes("glm-5.2"), out);
+});
+
+test("down + enter confirms the highlighted model label", () => {
+  let result: ModelPickerResult = "__pending__";
+  const picker = makePicker(false, (r) => {
+    result = r;
+  });
+  // filter to glm-5.2 / glm-5.2-flash, then move down to glm-5.2-flash and confirm
+  for (const ch of "glm") picker.handleInput(ch);
+  picker.handleInput(KEY.down);
+  picker.handleInput(KEY.enter);
+  assert.equal(result, "zenmux/glm-5.2-flash");
+});
+
+test("escape cancels and resolves to undefined", () => {
+  let result: ModelPickerResult = "__pending__";
+  const picker = makePicker(false, (r) => {
+    result = r;
+  });
+  picker.handleInput(KEY.escape);
+  assert.equal(result, undefined);
+});
+
+test("skip row is confirmable when allowSkip, resolving to the skip sentinel", () => {
+  let result: ModelPickerResult = "__pending__";
+  const picker = makePicker(true, (r) => {
+    result = r;
+  });
+  // initial selection is the skip row (index 0); confirm immediately
+  picker.handleInput(KEY.enter);
+  assert.equal(result, MODEL_PICKER_SKIP);
+});
+
+test("Tab cycles provider scope: all -> anthropic -> zenmux -> openai -> google -> all", () => {
+  const picker = makePicker(false, () => {});
+  const scopeLine = () => renderText(picker).split("\n").find((l) => l.startsWith("Scope:"))!;
+
+  // all: every provider is active/muted; "all" itself is the accent (here plain) entry
+  let scope = scopeLine();
+  assert.match(scope, /all/, scope);
+
+  picker.handleInput(KEY.tab); // -> anthropic
+  scope = scopeLine();
+  assert.match(scope, /anthropic/, scope);
+  assert.ok(!renderText(picker).includes("gpt-5.6-luna"), "openai model hidden in anthropic scope");
+
+  picker.handleInput(KEY.tab); // -> zenmux
+  assert.match(scopeLine(), /zenmux/, scopeLine());
+  assert.ok(renderText(picker).includes("glm-5.2"), "zenmux models shown in zenmux scope");
+  assert.ok(!renderText(picker).includes("claude-sonnet"), "anthropic hidden in zenmux scope");
+
+  picker.handleInput(KEY.tab); // -> openai
+  picker.handleInput(KEY.tab); // -> google
+  picker.handleInput(KEY.tab); // -> all (wraps)
+  assert.match(scopeLine(), /all/, scopeLine());
+  assert.ok(renderText(picker).includes("claude-sonnet"), "all scope shows every provider");
+});

package/extensions/rv-model-picker.ts

@@ -0,0 +1,313 @@
+/**
+ * Inline, searchable model picker built on Pi's TUI component primitives.
+ *
+ * Pi's `ui.select` dialog is a flat list (arrows + enter + escape) with no
+ * in-place search or grouping, which is painful for a long model catalog. This
+ * component composes `Input` + a filtered list (using `fuzzyFilter`) and is
+ * shown via `ctx.ui.custom(...)`, which grants keyboard focus so `handleInput`
+ * drives the whole flow:
+ *
+ *   - type → live fuzzy filter (e.g. "zenmux glm" matches `zenmux/glm-5.2`)
+ *   - ↑↓ / PgUp·PgDn → move selection
+ *   - Enter → confirm the highlighted model
+ *   - Tab → cycle the provider scope (all → provider1 → … → all)
+ *   - Esc → cancel
+ *
+ * It is a pure Pi-tui `Component`; the host `custom` factory owns focus and
+ * input routing. The wizard falls back to the `select`-based picker when
+ * `custom` is unavailable (print / RPC modes without a TUI).
+ */
+
+import {
+  Container,
+  Input,
+  Spacer,
+  Text,
+  fuzzyFilter,
+  getKeybindings,
+  type Component,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import type { ModelInfo } from "./rv-completions.js";
+import type { RvLocale } from "./rv-locale.js";
+
+/** Theme shape we use; the host passes a real `Theme` to the custom factory. */
+type PickerTheme = {
+  fg: (color: "accent" | "muted" | "warning" | "success" | "error" | "text", text: string) => string;
+  bold: (text: string) => string;
+};
+
+/** Result of the picker: a chosen label, the skip sentinel, or cancel (undefined). */
+export type ModelPickerResult = string | "__skip__" | undefined;
+
+export const MODEL_PICKER_SKIP = "__skip__";
+
+const MAX_VISIBLE = 12;
+
+/** A flattened, selectable row: either a real model or the synthetic skip row. */
+type Row = { kind: "model"; label: string; provider: string; id: string } | { kind: "skip" };
+
+/**
+ * Build the selectable rows from an already-ranked model list. The caller
+ * (wizard) owns preset ranking via `rankModelsWithPresets`; this only flattens
+ * and optionally prepends the skip row so it stays a pure UI component.
+ */
+export function pickerRows(ranked: ModelInfo[], allowSkip: boolean): Row[] {
+  const rows: Row[] = ranked.map((m) => ({ kind: "model", label: m.label, provider: m.provider, id: m.id }));
+  return allowSkip ? [{ kind: "skip" }, ...rows] : rows;
+}
+
+/** Distinct providers in rank order (first occurrence wins), for Tab scope cycling. */
+export function pickerProviders(ranked: ModelInfo[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const m of ranked) {
+    if (!seen.has(m.provider)) {
+      seen.add(m.provider);
+      out.push(m.provider);
+    }
+  }
+  return out;
+}
+
+function rowSearchText(r: Row): string {
+  if (r.kind === "skip") return "skip pi default 跳过";
+  return `${r.provider} ${r.id} ${r.label}`;
+}
+
+/**
+ * Inline searchable model picker component.
+ *
+ * Construct via `RvModelPickerComponent.create(...)` inside the `custom`
+ * factory and return it; the host grants focus and forwards keystrokes to
+ * `handleInput`. Call `done` with the chosen label, `MODEL_PICKER_SKIP`, or
+ * `undefined` (cancel).
+ */
+export class RvModelPickerComponent implements Component {
+  private readonly tui: TUI;
+  private readonly theme: PickerTheme;
+  private readonly keybindings: KeybindingsManager;
+  private readonly done: (result: ModelPickerResult) => void;
+  private readonly locale: RvLocale;
+  private readonly zh: boolean;
+  private readonly allRows: Row[];
+  private readonly providers: string[];
+
+  private readonly root = new Container();
+  private readonly searchInput: Input;
+  private readonly listContainer = new Container();
+  private readonly hint: Text;
+  private readonly scopeText: Text;
+
+  private scope: string = "all"; // "all" or a provider name
+  private filteredRows: Row[];
+  private selectedIndex = 0;
+
+  private constructor(opts: {
+    tui: TUI;
+    theme: PickerTheme;
+    keybindings: KeybindingsManager;
+    done: (result: ModelPickerResult) => void;
+    locale: RvLocale;
+    ranked: ModelInfo[];
+    allowSkip: boolean;
+    title: string;
+  }) {
+    this.tui = opts.tui;
+    this.theme = opts.theme;
+    this.keybindings = opts.keybindings;
+    this.done = opts.done;
+    this.locale = opts.locale;
+    this.zh = opts.locale === "zh";
+    this.allRows = pickerRows(opts.ranked, opts.allowSkip);
+    this.providers = pickerProviders(opts.ranked);
+
+    this.root.addChild(new Spacer(1));
+    this.hint = new Text("", 0, 0);
+    this.root.addChild(this.hint);
+    this.root.addChild(new Spacer(1));
+
+    this.searchInput = new Input();
+    this.root.addChild(this.searchInput);
+    this.root.addChild(new Spacer(1));
+
+    this.scopeText = new Text("", 0, 0);
+    this.root.addChild(this.scopeText);
+    this.root.addChild(new Spacer(1));
+
+    this.root.addChild(this.listContainer);
+    this.root.addChild(new Spacer(1));
+
+    this.filteredRows = this.allRows;
+    this.updateHint(opts.title);
+    this.updateScopeText();
+    this.updateList();
+  }
+
+  /** Factory used by the wizard inside `ctx.ui.custom(factory)`. */
+  static create(
+    tui: TUI,
+    theme: PickerTheme,
+    keybindings: KeybindingsManager,
+    done: (result: ModelPickerResult) => void,
+    input: { locale: RvLocale; ranked: ModelInfo[]; allowSkip: boolean; title: string },
+  ): RvModelPickerComponent {
+    return new RvModelPickerComponent({ tui, theme, keybindings, done, ...input });
+  }
+
+  // --- Component interface -------------------------------------------------
+
+  render(width: number): string[] {
+    return this.root.render(width);
+  }
+
+  invalidate(): void {
+    this.root.invalidate();
+  }
+
+  handleInput(keyData: string): void {
+    const kb = this.keybindings;
+    if (kb.matches(keyData, "tui.input.tab")) {
+      this.cycleScope();
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.up")) {
+      this.moveSelection(-1);
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.down")) {
+      this.moveSelection(1);
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.pageUp")) {
+      this.moveSelection(-MAX_VISIBLE);
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.pageDown")) {
+      this.moveSelection(MAX_VISIBLE);
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.confirm")) {
+      this.confirmSelection();
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.cancel")) {
+      this.done(undefined);
+      return;
+    }
+    // Everything else (printable chars, backspace, etc.) feeds the search box.
+    this.searchInput.handleInput(keyData);
+    this.applyFilter(this.searchInput.getValue());
+  }
+
+  // --- behavior ------------------------------------------------------------
+
+  private cycleScope(): void {
+    if (this.providers.length === 0) return;
+    if (this.scope === "all") {
+      this.scope = this.providers[0];
+    } else {
+      const idx = this.providers.indexOf(this.scope);
+      this.scope = idx >= 0 && idx < this.providers.length - 1 ? this.providers[idx + 1] : "all";
+    }
+    this.applyFilter(this.searchInput.getValue());
+    this.updateScopeText();
+  }
+
+  private activeRows(): Row[] {
+    if (this.scope === "all") return this.allRows;
+    return this.allRows.filter((r) => r.kind === "model" && r.provider === this.scope);
+  }
+
+  private applyFilter(query: string): void {
+    const active = this.activeRows();
+    this.filteredRows = query.trim()
+      ? fuzzyFilter(active, query, rowSearchText)
+      : active;
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredRows.length - 1));
+    if (this.filteredRows.length === 0) this.selectedIndex = 0;
+    this.updateList();
+    this.tui.requestRender();
+  }
+
+  private moveSelection(delta: number): void {
+    if (this.filteredRows.length === 0) return;
+    const n = this.filteredRows.length;
+    // wrap for single-step, clamp for page jumps
+    if (Math.abs(delta) === 1) {
+      this.selectedIndex = (this.selectedIndex + delta + n) % n;
+    } else {
+      this.selectedIndex = Math.max(0, Math.min(n - 1, this.selectedIndex + delta));
+    }
+    this.updateList();
+    this.tui.requestRender();
+  }
+
+  private confirmSelection(): void {
+    const row = this.filteredRows[this.selectedIndex];
+    if (!row) return;
+    if (row.kind === "skip") {
+      this.done(MODEL_PICKER_SKIP);
+    } else {
+      this.done(row.label);
+    }
+  }
+
+  private updateHint(title: string): void {
+    const hints = [
+      this.theme.fg("muted", this.zh ? "输入关键词过滤（如 glm-5.2 或 zenmux glm）" : "type to filter (e.g. glm-5.2 or zenmux glm)"),
+      "  " + this.theme.fg("muted", this.zh ? "Tab 切换 provider" : "Tab switch provider"),
+      "  " + this.theme.fg("muted", this.zh ? "↑↓ 选择" : "↑↓ select"),
+      "  " + this.theme.fg("muted", this.zh ? "回车确认 · Esc 取消" : "Enter confirm · Esc cancel"),
+    ];
+    this.hint.setText(`${this.theme.bold(title)}  ${hints.join("  ")}`);
+  }
+
+  private updateScopeText(): void {
+    const allLabel = this.zh ? "全部" : "all";
+    const parts = [this.scope === "all" ? this.theme.fg("accent", allLabel) : this.theme.fg("muted", allLabel)];
+    for (const p of this.providers) {
+      parts.push(p === this.scope ? this.theme.fg("accent", p) : this.theme.fg("muted", p));
+    }
+    const sep = this.theme.fg("muted", " | ");
+    this.scopeText.setText(this.theme.fg("muted", this.zh ? "Scope: " : "Scope: ") + parts.join(sep));
+  }
+
+  private updateList(): void {
+    this.listContainer.clear();
+    const rows = this.filteredRows;
+    const max = MAX_VISIBLE;
+    const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(max / 2), rows.length - max));
+    const end = Math.min(start + max, rows.length);
+
+    if (rows.length === 0) {
+      this.listContainer.addChild(new Text(this.theme.fg("muted", this.zh ? "  没有匹配的模型" : "  No matching models"), 0, 0));
+      return;
+    }
+
+    for (let i = start; i < end; i++) {
+      const row = rows[i];
+      const isSelected = i === this.selectedIndex;
+      const line = this.renderRow(row, isSelected);
+      this.listContainer.addChild(new Text(line, 0, 0));
+    }
+
+    if (start > 0 || end < rows.length) {
+      this.listContainer.addChild(new Text(this.theme.fg("muted", `  (${this.selectedIndex + 1}/${rows.length})`), 0, 0));
+    }
+  }
+
+  private renderRow(row: Row, isSelected: boolean): string {
+    if (row.kind === "skip") {
+      const text = this.zh ? "跳过（用 Pi 默认）" : "Skip (Pi default)";
+      return isSelected
+        ? this.theme.fg("accent", "→ ") + this.theme.fg("accent", text)
+        : `  ${this.theme.fg("muted", text)}`;
+    }
+    const prefix = isSelected ? this.theme.fg("accent", "→ ") : "  ";
+    const modelText = isSelected ? this.theme.fg("accent", row.id) : this.theme.fg("text", row.id);
+    const badge = this.theme.fg("muted", `[${row.provider}]`);
+    return `${prefix}${modelText} ${badge}`;
+  }
+}

package/extensions/rv-model-priorities.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   DEFAULT_REVIEW_MODEL_PRIORITIES,
   matchPresetEntry,
@@ -40,13 +40,20 @@ describe("resolveReviewProfile", () => {
 
 describe("matchPresetEntry", () => {
   const registry = [
-    m("openai", "gpt-5.5"),
+    m("openai-codex", "gpt-5.6-sol"),
+    m("openai-codex", "gpt-5.6-terra"),
+    m("openai-codex", "gpt-5.6-luna"),
     m("zhipu", "glm-5.2-chat"),
-    m("moonshot", "kimi-k2.7-preview"),
+    m("moonshot", "kimi-k2.7-code"),
     m("moonshot", "kimi-k2.5"),
     m("anthropic", "claude-opus-4-8"),
     m("anthropic", "claude-opus-4-6"),
+    m("anthropic", "claude-sonnet-4-5"),
+    m("anthropic", "claude-fable-5"),
     m("deepseek", "deepseek-v4-pro"),
+    m("deepseek", "deepseek-v4-flash"),
+    m("xai", "grok-4.5"),
+    m("minimax", "minimax-m3"),
   ];
 
   it("picks newest kimi when versionPrefer 2.7", () => {
@@ -56,14 +63,27 @@ describe("matchPresetEntry", () => {
     assert.match(hit!.id, /2\.7|k2\.7/i);
   });
 
-  it("ranks gpt-5.5 first for code presets", () => {
+  it("ranks fast-review models first for code presets", () => {
     const ordered = rankModelsWithPresets(registry, "code", DEFAULT_REVIEW_MODEL_PRIORITIES);
-    assert.equal(ordered[0].id, "gpt-5.5");
-    assert.equal(ordered[1].id, "glm-5.2-chat");
+    assert.equal(ordered[0].id, "claude-sonnet-4-5");
+    assert.equal(ordered[1].id, "deepseek-v4-flash");
+    assert.ok(ordered.some((row) => row.id === "gpt-5.6-terra"));
+    assert.ok(ordered.some((row) => row.id === "gpt-5.6-luna"));
   });
 
-  it("ranks claude-opus-4-8 before older opus for plan", () => {
+  it("ranks complex/plan models with sol then opus then fable", () => {
     const ordered = rankModelsWithPresets(registry, "plan", DEFAULT_REVIEW_MODEL_PRIORITIES);
-    assert.equal(ordered[0].id, "claude-opus-4-8");
+    assert.equal(ordered[0].id, "gpt-5.6-sol");
+    assert.equal(ordered[1].id, "claude-opus-4-8");
+    assert.equal(ordered[2].id, "claude-fable-5");
+    assert.ok(ordered.some((row) => row.id === "deepseek-v4-pro"));
+    assert.ok(ordered.some((row) => row.id === "grok-4.5"));
   });
-});
+
+  it("ranks vision/frontend with claude then gpt then kimi", () => {
+    const ordered = rankModelsWithPresets(registry, "frontend", DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.match(ordered[0].id, /claude/i);
+    assert.ok(ordered.some((row) => /gpt/i.test(row.id)));
+    assert.ok(ordered.some((row) => /kimi/i.test(row.id) && /2\.7/i.test(row.id)));
+  });
+});

package/extensions/rv-model-priorities.ts

@@ -15,21 +15,36 @@ export type ReviewModelPriorities = {
   plan: PresetModelEntry[];
 };
 
+/**
+ * Default priorities when resources/rv-model-priorities.json is missing.
+ * - code: fast review
+ * - plan: complex / architecture / 方案评审 (max thinking)
+ * - frontend: vision / UI / multimodal
+ */
 export const DEFAULT_REVIEW_MODEL_PRIORITIES: ReviewModelPriorities = {
   code: [
-    { idContains: "gpt-5.5", thinking: "xhigh" },
-    { idContains: "glm-5.2", thinking: "high" },
+    { idContains: "claude-sonnet", versionPrefer: "5", thinking: "xhigh" },
+    { idContains: "deepseek-v4-flash", thinking: "xhigh" },
+    { idContains: "glm-5.2", thinking: "xhigh" },
+    { idContains: "minimax-m3", thinking: "xhigh" },
+    { idContains: "grok-4.5", thinking: "xhigh" },
+    { idContains: "gpt-5.6-terra" },
+    { idContains: "gpt-5.6-luna", thinking: "xhigh" },
   ],
   frontend: [
+    { idContains: "claude" },
+    { idContains: "gpt" },
     { idContains: "kimi", versionPrefer: "2.7" },
-    { idContains: "claude-sonnet", versionPrefer: "5" },
-    { idContains: "minimax-m3" },
+    { idContains: "minimax-m3", thinking: "xhigh" },
   ],
   plan: [
-    { idContains: "claude-opus-4-8" },
-    { idContains: "claude-opus-4", versionPrefer: "8" },
-    { idContains: "deepseek-v4-pro" },
-    { idContains: "deepseek-v4" },
+    { idContains: "gpt-5.6-sol", thinking: "xhigh" },
+    { idContains: "claude-opus-4-8", thinking: "xhigh" },
+    { idContains: "claude-opus-4", versionPrefer: "8", thinking: "xhigh" },
+    { idContains: "claude-fable-5", thinking: "xhigh" },
+    { idContains: "glm-5.2", thinking: "xhigh" },
+    { idContains: "deepseek-v4-pro", thinking: "xhigh" },
+    { idContains: "grok-4.5", thinking: "xhigh" },
   ],
 };