@zephyrdeng/pi-review 0.6.0 → 0.6.1

package/README.md

@@ -224,9 +224,12 @@ The `/rv` command injects a task message for the parent agent (Pi host rules: de
 
 Argument completions are context-aware. After the host session starts, `/rv` reads the live model registry and offers:
 
-- **Model list** after `--model `, ranked by review fit (reasoning, context window, cross-vendor bonus for adversarial review) with a `★ 推荐` marker and a one-line reason.
-- **Thinking suffix** after `provider/model:` — only levels the chosen model actually supports (e.g. `:high`, `:xhigh`); non-reasoning models offer none.
-- **`--mode` / `--thinking` / flag** completions with hints, and **scene templates** (e.g. “审代码改动（推荐配置）”) at the top level that pre-fill a recommended command.
+- **Model list** after `--model `: candidates come from the live Pi registry; order follows **`resources/rv-model-priorities.json`** (override with `PI_REVIEW_RV_PRIORITIES`). Presets match registry ids by substring and prefer newer version strings (e.g. kimi `2.7`, `claude-opus-4-8`). Profiles: **code** (e.g. gpt-5.5 `:xhigh`, glm-5.2 `:high`), **frontend** (vue/css/… → kimi, claude-sonnet, minimax-m3), **plan/challenge** (claude-opus-4-8, deepseek-v4-pro, …).
+- **Thinking suffix** after `provider/model:` — only levels the chosen model actually supports.
+- **Semantic phrases** (e.g. `code review` / 代码审核, `查看模型列表`) in addition to flags; orchestration prompts follow **session locale** (zh/en) for summaries.
+- **Scene templates** at the top level (code / frontend / plan presets).
+
+**Claude Code / Codex:** the bundled skill includes **[skills/pi-review/references/model-selection.md](skills/pi-review/references/model-selection.md)** — same presets as `/rv` for choosing `--model` after `pi-review models`.
 
 Completions are a hint layer only; execution remains skill-driven. When the model registry is unavailable (e.g. non-TUI mode), `/rv` falls back to the static hint list.
 

package/extensions/review.ts

@@ -3,6 +3,7 @@ import {
   buildRvCompletions,
   type ModelInfo,
 } from "./rv-completions.js";
+import { detectRvLocale } from "./rv-locale.js";
 import {
   buildRvOrchestrationPrompt,
   parseRvArgs,
@@ -18,6 +19,28 @@ import {
  */
 let capturedModels: ModelInfo[] | undefined;
 let capturedPrimaryProvider: string | undefined;
+let capturedLocale: ReturnType<typeof detectRvLocale> = "en";
+
+function sampleSessionText(
+  sessionManager: { getEntries?: () => Array<{ type?: string; content?: unknown }> },
+): string[] {
+  const out: string[] = [];
+  try {
+    const entries = sessionManager.getEntries?.() ?? [];
+    for (let i = entries.length - 1; i >= 0 && out.length < 12; i--) {
+      const e = entries[i];
+      if (e.type !== "message") continue;
+      const c = e.content;
+      if (typeof c === "string") out.push(c);
+      else if (c && typeof c === "object" && "text" in c && typeof (c as { text: string }).text === "string") {
+        out.push((c as { text: string }).text);
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+  return out;
+}
 
 function toModelInfo(m: {
   provider: string;
@@ -50,12 +73,22 @@ export default function piReviewExtension(pi: ExtensionAPI) {
       const available = ctx.modelRegistry?.getAvailable?.() ?? [];
       capturedModels = available.map((m) => toModelInfo(m as unknown as Parameters<typeof toModelInfo>[0]));
       capturedPrimaryProvider = ctx.model?.provider;
+      capturedLocale = detectRvLocale(sampleSessionText(ctx.sessionManager));
     } catch {
       capturedModels = undefined;
       capturedPrimaryProvider = undefined;
+      capturedLocale = "en";
     }
   });
 
+  function localeForHandler(ctx: { sessionManager?: Parameters<typeof sampleSessionText>[0] }): typeof capturedLocale {
+    try {
+      return detectRvLocale(sampleSessionText(ctx.sessionManager ?? { getEntries: () => [] }));
+    } catch {
+      return capturedLocale;
+    }
+  }
+
   pi.registerCommand("rv", {
     description:
       "Delegate pi-review to the agent. Usage: /rv [--mode plan|challenge] [--model id] [--thinking level] [--keep-session] [--no-stream] @target | /rv --continue <handle> [opts] [text] | models",
@@ -65,6 +98,7 @@ export default function piReviewExtension(pi: ExtensionAPI) {
         const dynamic = buildRvCompletions(prefix, {
           models: capturedModels,
           primaryProvider: capturedPrimaryProvider,
+          locale: capturedLocale,
         });
         if (dynamic && dynamic.length) return dynamic;
       }
@@ -93,7 +127,7 @@ export default function piReviewExtension(pi: ExtensionAPI) {
         return;
       }
 
-      pi.sendUserMessage(buildRvOrchestrationPrompt(parsed));
+      pi.sendUserMessage(buildRvOrchestrationPrompt(parsed, localeForHandler(ctx)));
     },
   });
 }

package/extensions/rv-completions.test.ts

@@ -6,10 +6,11 @@ import {
   fuzzyMatch,
   MODE_HINTS,
   rankModelsForReview,
-  scoreModelForReview,
   tokenizeArgPrefix,
   type ModelInfo,
 } from "./rv-completions.js";
+import { rvUi } from "./rv-locale.js";
+import { DEFAULT_REVIEW_MODEL_PRIORITIES } from "./rv-model-priorities.js";
 
 function model(partial: Partial<ModelInfo> & Pick<ModelInfo, "provider" | "id">): ModelInfo {
   return {
@@ -72,28 +73,23 @@ describe("extractSignals", () => {
     assert.equal(sig.targetExt, "ts");
   });
 
-  it("carries primary provider for cross-vendor bonus", () => {
+  it("carries primary provider on signals", () => {
     const sig = extractSignals([], { primaryProvider: "anthropic" });
     assert.equal(sig.primaryProvider, "anthropic");
   });
 });
 
-describe("scoreModelForReview / rankModelsForReview", () => {
-  it("scores reasoning + cross-vendor + xhigh higher than a cheap non-reasoning model", () => {
-    const sig = { mode: "challenge", hasTarget: true, targetExt: "md", primaryProvider: "anthropic" };
-    const opus = scoreModelForReview(MODELS[0], sig);
-    const gpt = scoreModelForReview(MODELS[1], sig);
-    const flash = scoreModelForReview(MODELS[2], sig);
-    assert.ok(gpt.score > opus.score, `gpt (${gpt.score}) should beat opus (${opus.score}) for challenge+cross-vendor`);
-    assert.ok(opus.score > flash.score, "opus should beat the non-reasoning flash");
-    assert.ok(flash.score >= 2, "flash still gets context-window points");
+describe("rankModelsForReview", () => {
+  it("puts preset code models first when registered", () => {
+    const sig = extractSignals(["@src/a.ts"], {});
+    const ranked = rankModelsForReview(MODELS, sig, DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ranked[0].id, "gpt-5.5");
   });
 
-  it("ranks descending by score", () => {
-    const sig = { mode: "plan", hasTarget: false, primaryProvider: "anthropic" };
-    const ranked = rankModelsForReview(MODELS, sig);
-    assert.equal(ranked[0].id, "gpt-5.5");
-    assert.equal(ranked[ranked.length - 1].id, "gemini-3-flash");
+  it("puts preset plan models first for plan mode", () => {
+    const sig = extractSignals(["--mode", "plan"], {});
+    const ranked = rankModelsForReview(MODELS, sig, DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ranked[0].id, "claude-opus-4-6");
   });
 });
 
@@ -106,13 +102,17 @@ describe("fuzzyMatch", () => {
 });
 
 describe("buildRvCompletions", () => {
-  const deps = { models: MODELS, primaryProvider: "anthropic" };
+  const deps = {
+    models: MODELS,
+    primaryProvider: "anthropic",
+    priorities: DEFAULT_REVIEW_MODEL_PRIORITIES,
+  };
 
   it("returns dynamic model list after --model, with recommended marker on top items", () => {
     const items = buildRvCompletions("@x.md --model ", deps);
     assert.ok(items, "expected items");
     assert.ok(items!.some((i) => i.label === "openai/gpt-5.5"));
-    const top = items!.find((i) => i.description?.includes("★ 推荐"));
+    const top = items!.find((i) => i.description?.includes("Suggested"));
     assert.ok(top, "expected at least one recommended item");
     // value carries the head so applyCompletion replaces the whole arg safely
     assert.ok(top!.value.startsWith("@x.md --model "));
@@ -169,11 +169,11 @@ describe("buildRvCompletions", () => {
 
   it("offers scene templates + models keyword at empty top level", () => {
     const items = buildRvCompletions("", deps);
+    const ui = rvUi("en");
     assert.ok(items);
-    assert.ok(items!.some((i) => i.label === "models"));
-    assert.ok(items!.some((i) => i.label.startsWith("审代码改动")));
-    // template values end with " @" so the user can keep typing a path
-    const tmpl = items!.find((i) => i.label.startsWith("审代码改动"))!;
+    assert.ok(items!.some((i) => i.label === ui.listModels));
+    assert.ok(items!.some((i) => i.label === ui.codePreset));
+    const tmpl = items!.find((i) => i.label === ui.codePreset)!;
     assert.ok(tmpl.value.endsWith(" @"));
   });
 
@@ -202,15 +202,12 @@ describe("buildRvCompletions", () => {
     }
   });
 
-  it("scene templates omit the thinking colon for non-reasoning models (note #1 fix)", () => {
+  it("omits preset scene templates when registry has no preset id match", () => {
     const nonReasoning = [{ ...MODELS[2], thinkingLevels: [] }] as ModelInfo[];
-    const items = buildRvCompletions("", { models: nonReasoning });
+    const items = buildRvCompletions("", { models: nonReasoning, priorities: DEFAULT_REVIEW_MODEL_PRIORITIES });
     assert.ok(items);
-    const tmpl = items!.find((i) => i.label.startsWith("审代码改动"));
-    assert.ok(tmpl, "expected a scene template even for non-reasoning models");
-    // Must NOT contain a dangling colon like `gemini-3-flash: @`
-    assert.doesNotMatch(tmpl!.value, /flash:\s@/);
-    assert.match(tmpl!.value, /flash @/);
+    assert.ok(!items!.some((i) => i.label === rvUi("en").codePreset));
+    assert.ok(items!.some((i) => i.label === rvUi("en").listModels));
   });
 
   it("falls back gracefully when models are unavailable (static flags still work)", () => {

package/extensions/rv-completions.ts

@@ -1,16 +1,22 @@
 /**
  * Pure, testable /rv argument-completion logic.
  *
- * This module deliberately avoids importing pi types so the tokenizer, state
- * machine, and model scorer can be unit-tested with `node:test` and reused
- * across hosts. The thin runtime adapter (registry capture + AutocompleteItem
- * shaping) lives in `review.ts`.
- *
- * Completion items are returned "续写式": `value` always carries the already-typed
- * head tokens because pi-tui's `applyCompletion` replaces the *entire* argument
- * text after the slash command with `item.value`.
+ * Avoids pi types so tokenizer + preset ordering can be unit-tested.
+ * Completion `value` must include the typed head (pi-tui replaces the whole arg).
  */
 
+import { type RvLocale, rvUi } from "./rv-locale.js";
+import { semanticCompletionItems, SEMANTIC_PHRASES } from "./rv-semantic.js";
+import {
+  loadReviewModelPriorities,
+  primaryPresetForProfile,
+  rankModelsWithPresets,
+  resolvePresetOrderedModels,
+  resolveReviewProfile,
+  type ReviewModelPriorities,
+  type ReviewProfile,
+} from "./rv-model-priorities.js";
+
 export type AutocompleteItem = {
   value: string;
   label: string;
@@ -36,18 +42,18 @@ export const RV_FLAGS = [
 ] as const;
 
 export const MODE_HINTS: Record<string, string> = {
-  code: "代码 / diff / MR 审核",
-  plan: "架构 / 计划评审",
-  challenge: "对抗性方案评审",
+  code: "Code / diff / MR review",
+  plan: "Architecture or plan review",
+  challenge: "Adversarial plan review",
 };
 
 export const FLAG_HINTS: Record<string, string> = {
-  "--mode": "审核模式 code|plan|challenge",
+  "--mode": "Review mode: code | plan | challenge",
   "--model": "provider/model[:thinking]",
-  "--thinking": "off|minimal|low|medium|high|xhigh",
-  "--keep-session": "保留会话，可用 /rv --continue 追问",
-  "--no-stream": "缓冲输出到结束（非默认）",
-  "--continue": "继续既有 review 会话",
+  "--thinking": "off | minimal | low | medium | high | xhigh",
+  "--keep-session": "Keep session for /rv --continue follow-up",
+  "--no-stream": "Buffer output until exit (not default)",
+  "--continue": "Resume an existing review session",
 };
 
 /** Minimal model metadata we need; converted from the host's Model registry. */
@@ -74,6 +80,31 @@ export interface ReviewSignals {
 export interface CompletionDeps {
   models?: ModelInfo[];
   primaryProvider?: string;
+  priorities?: ReviewModelPriorities;
+  locale?: RvLocale;
+}
+
+function localeOf(deps: CompletionDeps): RvLocale {
+  return deps.locale ?? "en";
+}
+
+function modeFromSemanticHead(head: string[]): string | undefined {
+  const joined = head.join(" ").toLowerCase();
+  for (const row of SEMANTIC_PHRASES) {
+    if (!row.apply.mode) continue;
+    for (const p of row.phrases) {
+      if (joined.includes(p.toLowerCase())) return row.apply.mode;
+    }
+  }
+  return undefined;
+}
+
+function getPriorities(deps: CompletionDeps): ReviewModelPriorities {
+  return deps.priorities ?? loadReviewModelPriorities();
+}
+
+export function reviewProfileForSignals(sig: ReviewSignals): ReviewProfile {
+  return resolveReviewProfile(sig.mode, sig.targetExt);
 }
 
 // ---------------------------------------------------------------------------
@@ -111,12 +142,6 @@ export function tokenizeArgPrefix(prefix: string): TokenizedArgs {
 // Signal extraction
 // ---------------------------------------------------------------------------
 
-const CODE_EXTS = new Set([
-  "ts", "tsx", "js", "jsx", "mjs", "cjs", "py", "rb", "go", "rs", "java", "kt",
-  "c", "cc", "cpp", "h", "hpp", "cs", "php", "swift", "scala", "sh", "sql",
-  "vue", "svelte",
-]);
-const PLAN_EXTS = new Set(["md", "markdown", "txt", "rst", "adoc"]);
 
 function extOf(token: string): string | undefined {
   const cleaned = token.replace(/^['"]|['"]$/g, "").replace(/^@/, "");
@@ -127,7 +152,8 @@ function extOf(token: string): string | undefined {
 export function extractSignals(head: string[], deps: CompletionDeps): ReviewSignals {
   const target = head.find((t) => t.startsWith("@"));
   const modeIdx = head.indexOf("--mode");
-  const mode = modeIdx >= 0 ? head[modeIdx + 1] : "code";
+  const mode =
+    (modeIdx >= 0 ? head[modeIdx + 1] : undefined) ?? modeFromSemanticHead(head) ?? "code";
   return {
     mode,
     hasTarget: Boolean(target),
@@ -137,46 +163,27 @@ export function extractSignals(head: string[], deps: CompletionDeps): ReviewSign
 }
 
 // ---------------------------------------------------------------------------
-// Model scoring (P2 rule engine — pure, no LLM in the completion hot path)
+// Model ordering: registry + preset priorities (no LLM)
 // ---------------------------------------------------------------------------
 
-export function scoreModelForReview(
-  m: ModelInfo,
-  sig: ReviewSignals,
-): { score: number; reason: string } {
-  let score = 0;
-  const reasons: string[] = [];
-  if (m.reasoning) {
-    score += 3;
-    reasons.push("reasoning");
-  }
-  if (m.contextWindow >= 200_000) score += 2;
-  else if (m.contextWindow >= 100_000) score += 1;
-  if (sig.primaryProvider && m.provider !== sig.primaryProvider) {
-    score += 1;
-    reasons.push("跨厂商交叉审核");
-  }
-  if ((sig.mode === "plan" || sig.mode === "challenge") && m.thinkingLevels.includes("xhigh")) {
-    score += 2;
-    reasons.push("xhigh 思考");
-  } else if (m.thinkingLevels.includes("high")) {
-    score += 1;
-  }
-  if (sig.targetExt && PLAN_EXTS.has(sig.targetExt) && m.reasoning) {
-    score += 1;
-    reasons.push("适合文档评审");
-  }
-  return { score, reason: reasons.filter(Boolean).join(" · ") };
-}
-
 export function rankModelsForReview(
   models: ModelInfo[],
   sig: ReviewSignals,
+  priorities?: ReviewModelPriorities,
 ): ModelInfo[] {
-  return models
-    .map((m) => ({ m, s: scoreModelForReview(m, sig).score }))
-    .sort((a, b) => b.s - a.s)
-    .map((x) => x.m);
+  const profile = reviewProfileForSignals(sig);
+  return rankModelsWithPresets(models, profile, priorities ?? loadReviewModelPriorities());
+}
+
+function presetDescription(
+  presetLabel: string,
+  profile: ReviewProfile,
+  presetRank: number | undefined,
+  locale: RvLocale,
+): string {
+  if (presetRank === undefined) return "";
+  const ui = rvUi(locale);
+  return `${ui.presetTier(presetRank)} · ${profile} · ${presetLabel}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -234,16 +241,16 @@ function wrap(
   }));
 }
 
-function thinkingDescription(level: string, sig: ReviewSignals): string {
+function thinkingDescription(level: string, sig: ReviewSignals, locale: RvLocale): string {
   const recommended = sig.mode === "code" ? "high" : "xhigh";
-  const star = level === recommended ? "★ 推荐 " : "";
+  const star = level === recommended ? rvUi(locale).thinkingSuggested : "";
   const map: Record<string, string> = {
-    off: "不思考（最快）",
-    minimal: "极简思考",
-    low: "低强度",
-    medium: "中强度",
-    high: "高强度（review 默认）",
-    xhigh: "极致思考（plan/challenge 推荐）",
+    off: "No thinking (fastest)",
+    minimal: "Minimal thinking",
+    low: "Low effort",
+    medium: "Medium effort",
+    high: "High effort (common for review)",
+    xhigh: "Max effort (plan/challenge)",
   };
   return `${star}${map[level] ?? level}`;
 }
@@ -259,22 +266,25 @@ function modelItems(
   sig: ReviewSignals,
   headPrefix: string,
   tail: string,
+  deps: CompletionDeps,
 ): AutocompleteItem[] | null {
-  const ranked = rankModelsForReview(models, sig);
-  const items = ranked.map((m, i) => {
-    const { score, reason } = scoreModelForReview(m, sig);
-    const recommended = i < 3 && score > 0;
-    const tag =
-      sig.mode === "plan" || sig.mode === "challenge" ? "plan/challenge" : "review";
+  const priorities = getPriorities(deps);
+  const profile = reviewProfileForSignals(sig);
+  const presetRows = resolvePresetOrderedModels(models, profile, priorities);
+  const presetByLabel = new Map(presetRows.map((p) => [p.model.label, p]));
+  const ranked = rankModelsWithPresets(models, profile, priorities);
+  const items = ranked.map((m) => {
+    const preset = presetByLabel.get(m.label);
+    const tag = profile;
     return {
       value: `${headPrefix}${m.label}`,
       label: m.label,
       description: [
-        recommended ? "★ 推荐" : "",
+        preset ? presetDescription(preset.presetLabel, profile, preset.presetRank, localeOf(deps)) : "",
         tag,
         m.reasoning ? "reasoning" : "",
         contextLabel(m.contextWindow),
-        reason,
+        preset?.thinking ? `preset thinking ${preset.thinking}` : "",
       ]
         .filter(Boolean)
         .join(" · "),
@@ -301,6 +311,7 @@ function thinkingSuffixItems(
   models: ModelInfo[],
   headPrefix: string,
   sig: ReviewSignals,
+  deps: CompletionDeps,
 ): AutocompleteItem[] | null {
   const colonIdx = tail.lastIndexOf(":");
   const modelPart = tail.slice(0, colonIdx);
@@ -319,40 +330,64 @@ function thinkingSuffixItems(
   return filtered.map((level) => ({
     value: `${headPrefix}${modelPart}:${level}`,
     label: level,
-    description: thinkingDescription(level, sig),
+    description: thinkingDescription(level, sig, localeOf(deps)),
   }));
 }
 
+function thinkingSuffixForModel(m: ModelInfo, want?: string): string {
+  const lvl =
+    want && m.thinkingLevels.includes(want)
+      ? want
+      : want && m.thinkingLevels.includes("high")
+        ? "high"
+        : m.thinkingLevels.includes("xhigh")
+          ? "xhigh"
+          : m.thinkingLevels.includes("high")
+            ? "high"
+            : (m.thinkingLevels[0] ?? "");
+  return lvl ? `:${lvl}` : "";
+}
+
 function sceneTemplates(
-  top: ModelInfo | undefined,
+  models: ModelInfo[],
+  sig: ReviewSignals,
   headPrefix: string,
   tail: string,
+  deps: CompletionDeps,
 ): AutocompleteItem[] {
-  if (!top) return [];
-  const pref = (m: ModelInfo, want: string): string => {
-    if (m.thinkingLevels.includes(want)) return want;
-    if (m.thinkingLevels.includes("high")) return "high";
-    return m.thinkingLevels[0] ?? "";
-  };
-  const suffix = (want: string): string => {
-    const lvl = pref(top, want);
-    return lvl ? `:${lvl}` : "";
-  };
+  const priorities = getPriorities(deps);
+  const codePrimary = primaryPresetForProfile(models, "code", priorities);
+  const planPrimary = primaryPresetForProfile(models, "plan", priorities);
+  const frontendPrimary = primaryPresetForProfile(models, "frontend", priorities);
+
+  const ui = rvUi(localeOf(deps));
+  const templates: { cmd: string; label: string }[] = [];
+  if (codePrimary) {
+    const m = codePrimary.model;
+    templates.push({
+      cmd: `${ui.modeCode} --model ${m.label}${thinkingSuffixForModel(m, codePrimary.thinking ?? "xhigh")} @`,
+      label: ui.codePreset,
+    });
+  }
+  if (frontendPrimary) {
+    const m = frontendPrimary.model;
+    templates.push({
+      cmd: `${ui.modeCode} --model ${m.label}${thinkingSuffixForModel(m, frontendPrimary.thinking)} @`,
+      label: ui.frontendPreset,
+    });
+  }
+  if (planPrimary) {
+    const m = planPrimary.model;
+    templates.push({
+      cmd: `${ui.modePlan} --model ${m.label}${thinkingSuffixForModel(m, planPrimary.thinking ?? "high")} @`,
+      label: ui.planPreset,
+    });
+    templates.push({
+      cmd: `${ui.modeChallenge} ${ui.keepSession} --model ${m.label}${thinkingSuffixForModel(m, "xhigh")} @`,
+      label: ui.challengePreset,
+    });
+  }
 
-  const templates = [
-    {
-      cmd: `--mode code --model ${top.label}${suffix("high")} @`,
-      label: "审代码改动（推荐配置）",
-    },
-    {
-      cmd: `--mode plan --model ${top.label}${suffix("high")} @`,
-      label: "架构 / 计划评审",
-    },
-    {
-      cmd: `--mode challenge --keep-session --model ${top.label}${suffix("xhigh")} @`,
-      label: "对抗性方案评审（可追问）",
-    },
-  ];
   return templates
     .filter((t) => fuzzyMatch(t.label, tail) || t.cmd.includes(tail))
     .map((t) => ({
@@ -382,21 +417,25 @@ function topLevelCompletions(
   const items: AutocompleteItem[] = [];
 
   // Scene templates (only at top level, before any target/mode chosen is fine).
-  const ranked = deps.models?.length ? rankModelsForReview(deps.models, sig) : [];
-  items.push(...sceneTemplates(ranked[0], headPrefix, tail));
+  if (deps.models?.length) {
+    items.push(...sceneTemplates(deps.models, sig, headPrefix, tail, deps));
+  }
+
+  items.push(...semanticCompletionItems(localeOf(deps), tail, headPrefix, head));
 
-  // `models` keyword.
-  if (fuzzyMatch("models", tail) || "models".startsWith(tail)) {
+  const ui = rvUi(localeOf(deps));
+  if (fuzzyMatch(ui.modelsKeyword, tail) || ui.modelsKeyword.startsWith(tail) || fuzzyMatch("models", tail)) {
     items.push({
-      value: `${headPrefix}models`,
-      label: "models",
-      description: "仅列出 pi-review 可用模型",
+      value: `${headPrefix}${ui.listModels}`,
+      label: ui.listModels,
+      description: ui.listModelsDesc,
     });
   }
 
-  // Flags.
-  const flags = flagItems(head, tail, headPrefix);
-  if (flags) items.push(...flags);
+  if (tail.startsWith("--")) {
+    const flags = flagItems(head, tail, headPrefix);
+    if (flags) items.push(...flags);
+  }
 
   return items.length ? items : null;
 }
@@ -418,10 +457,10 @@ export function buildRvCompletions(
   if (prev === "--model") {
     const colonIdx = tail.lastIndexOf(":");
     if (colonIdx !== -1 && tail.slice(0, colonIdx).includes("/")) {
-      const items = thinkingSuffixItems(tail, deps.models ?? [], headPrefix, sig);
+      const items = thinkingSuffixItems(tail, deps.models ?? [], headPrefix, sig, deps);
       return items;
     }
-    return modelItems(deps.models ?? [], sig, headPrefix, tail);
+    return modelItems(deps.models ?? [], sig, headPrefix, tail, deps);
   }
 
   // 2) --mode value position.

package/extensions/rv-locale.test.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { detectRvLocale } from "./rv-locale.js";
+
+describe("detectRvLocale", () => {
+  it("returns zh when recent messages are mostly Chinese", () => {
+    assert.equal(detectRvLocale(["帮我看一下这个方案", "好的"]), "zh");
+  });
+
+  it("returns en for English-only samples", () => {
+    assert.equal(detectRvLocale(["Please review this diff", "Thanks"]), "en");
+  });
+
+  it("defaults to en when empty", () => {
+    assert.equal(detectRvLocale([]), "en");
+  });
+});

package/extensions/rv-locale.ts

@@ -0,0 +1,81 @@
+/** Lightweight locale for /rv UI strings (no LLM). */
+
+export type RvLocale = "en" | "zh";
+
+const CJK_RE = /[\u4e00-\u9fff\u3400-\u4dbf]/;
+
+export function detectRvLocale(textSamples: string[]): RvLocale {
+  let cjk = 0;
+  let latin = 0;
+  for (const sample of textSamples) {
+    const t = sample.slice(0, 2000);
+    for (const ch of t) {
+      if (CJK_RE.test(ch)) cjk++;
+      else if (/[a-zA-Z]/.test(ch)) latin++;
+    }
+  }
+  if (cjk === 0 && latin === 0) return "en";
+  return cjk >= latin * 0.15 ? "zh" : "en";
+}
+
+export type RvUiStrings = {
+  modelsKeyword: string;
+  modelsDesc: string;
+  modeCode: string;
+  modePlan: string;
+  modeChallenge: string;
+  keepSession: string;
+  keepSessionDesc: string;
+  listModels: string;
+  listModelsDesc: string;
+  codePreset: string;
+  frontendPreset: string;
+  planPreset: string;
+  challengePreset: string;
+  suggested: string;
+  presetTier: (n: number) => string;
+  thinkingSuggested: string;
+};
+
+const UI: Record<RvLocale, RvUiStrings> = {
+  en: {
+    modelsKeyword: "models",
+    modelsDesc: "List pi-review models only",
+    modeCode: "code review",
+    modePlan: "plan review",
+    modeChallenge: "challenge review",
+    keepSession: "keep session for follow-up",
+    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)",
+    suggested: "Suggested",
+    presetTier: (n) => (n === 0 ? "Suggested" : `Preset #${n + 1}`),
+    thinkingSuggested: "Suggested ",
+  },
+  zh: {
+    modelsKeyword: "models",
+    modelsDesc: "仅列出 pi-review 可用模型",
+    modeCode: "代码审核",
+    modePlan: "方案审核",
+    modeChallenge: "对抗性审核",
+    keepSession: "保留会话可追问",
+    keepSessionDesc: "保留 review 会话，便于 /rv --continue",
+    listModels: "查看模型列表",
+    listModelsDesc: "列出当前可用 provider/model",
+    codePreset: "代码审核（推荐配置）",
+    frontendPreset: "前端 / 多模态审核（推荐）",
+    planPreset: "方案 / 架构审核（推荐）",
+    challengePreset: "对抗性方案审核（可追问）",
+    suggested: "推荐",
+    presetTier: (n) => (n === 0 ? "推荐" : `预设 #${n + 1}`),
+    thinkingSuggested: "推荐 ",
+  },
+};
+
+export function rvUi(locale: RvLocale): RvUiStrings {
+  return UI[locale];
+}

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

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  DEFAULT_REVIEW_MODEL_PRIORITIES,
+  matchPresetEntry,
+  rankModelsWithPresets,
+  resolveReviewProfile,
+  type PresetModelEntry,
+} from "./rv-model-priorities.js";
+import type { ModelInfo } from "./rv-completions.js";
+
+function m(provider: string, id: string, extra?: Partial<ModelInfo>): ModelInfo {
+  return {
+    provider,
+    id,
+    label: `${provider}/${id}`,
+    name: id,
+    reasoning: true,
+    contextWindow: 200_000,
+    thinkingLevels: ["high", "xhigh"],
+    ...extra,
+  };
+}
+
+describe("resolveReviewProfile", () => {
+  it("uses plan profile for plan/challenge mode", () => {
+    assert.equal(resolveReviewProfile("plan", "ts"), "plan");
+    assert.equal(resolveReviewProfile("challenge", "md"), "plan");
+  });
+
+  it("uses frontend profile for vue/svelte/css targets", () => {
+    assert.equal(resolveReviewProfile("code", "vue"), "frontend");
+    assert.equal(resolveReviewProfile("code", "css"), "frontend");
+  });
+
+  it("defaults to code profile", () => {
+    assert.equal(resolveReviewProfile("code", "ts"), "code");
+  });
+});
+
+describe("matchPresetEntry", () => {
+  const registry = [
+    m("openai", "gpt-5.5"),
+    m("zhipu", "glm-5.2-chat"),
+    m("moonshot", "kimi-k2.7-preview"),
+    m("moonshot", "kimi-k2.5"),
+    m("anthropic", "claude-opus-4-8"),
+    m("anthropic", "claude-opus-4-6"),
+    m("deepseek", "deepseek-v4-pro"),
+  ];
+
+  it("picks newest kimi when versionPrefer 2.7", () => {
+    const entry: PresetModelEntry = { idContains: "kimi", versionPrefer: "2.7" };
+    const hit = matchPresetEntry(registry, entry);
+    assert.ok(hit);
+    assert.match(hit!.id, /2\.7|k2\.7/i);
+  });
+
+  it("ranks gpt-5.5 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");
+  });
+
+  it("ranks claude-opus-4-8 before older opus for plan", () => {
+    const ordered = rankModelsWithPresets(registry, "plan", DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ordered[0].id, "claude-opus-4-8");
+  });
+});

package/extensions/rv-model-priorities.ts

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ModelInfo } from "./rv-completions.js";
+
+export type PresetModelEntry = {
+  idContains: string;
+  thinking?: string;
+  versionPrefer?: string;
+};
+
+export type ReviewModelPriorities = {
+  code: PresetModelEntry[];
+  frontend: PresetModelEntry[];
+  plan: PresetModelEntry[];
+};
+
+export const DEFAULT_REVIEW_MODEL_PRIORITIES: ReviewModelPriorities = {
+  code: [
+    { idContains: "gpt-5.5", thinking: "xhigh" },
+    { idContains: "glm-5.2", thinking: "high" },
+  ],
+  frontend: [
+    { idContains: "kimi", versionPrefer: "2.7" },
+    { idContains: "claude-sonnet", versionPrefer: "5" },
+    { idContains: "minimax-m3" },
+  ],
+  plan: [
+    { idContains: "claude-opus-4-8" },
+    { idContains: "claude-opus-4", versionPrefer: "8" },
+    { idContains: "deepseek-v4-pro" },
+    { idContains: "deepseek-v4" },
+  ],
+};
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PRIORITIES_PATH = path.resolve(__dirname, "../resources/rv-model-priorities.json");
+
+export function loadReviewModelPriorities(
+  filePath: string = process.env.PI_REVIEW_RV_PRIORITIES || DEFAULT_PRIORITIES_PATH,
+): ReviewModelPriorities {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw) as Partial<ReviewModelPriorities>;
+    return {
+      code: parsed.code?.length ? parsed.code : DEFAULT_REVIEW_MODEL_PRIORITIES.code,
+      frontend: parsed.frontend?.length ? parsed.frontend : DEFAULT_REVIEW_MODEL_PRIORITIES.frontend,
+      plan: parsed.plan?.length ? parsed.plan : DEFAULT_REVIEW_MODEL_PRIORITIES.plan,
+    };
+  } catch {
+    return DEFAULT_REVIEW_MODEL_PRIORITIES;
+  }
+}
+
+export type ReviewProfile = "code" | "frontend" | "plan";
+
+const FRONTEND_EXTS = new Set([
+  "vue", "svelte", "css", "scss", "sass", "less", "styl", "html", "htm",
+]);
+
+export function resolveReviewProfile(mode: string, targetExt?: string): ReviewProfile {
+  if (mode === "plan" || mode === "challenge") return "plan";
+  if (targetExt && FRONTEND_EXTS.has(targetExt)) return "frontend";
+  return "code";
+}
+
+function idVersionSortKey(id: string): string {
+  return id.toLowerCase();
+}
+
+export function matchPresetEntry(
+  models: ModelInfo[],
+  entry: PresetModelEntry,
+): ModelInfo | undefined {
+  const needle = entry.idContains.toLowerCase();
+  let candidates = models.filter((m) => m.id.toLowerCase().includes(needle));
+  if (entry.versionPrefer) {
+    const vp = entry.versionPrefer.toLowerCase();
+    const withVersion = candidates.filter((m) => m.id.toLowerCase().includes(vp));
+    if (withVersion.length) candidates = withVersion;
+  }
+  if (!candidates.length) return undefined;
+  candidates.sort((a, b) =>
+    idVersionSortKey(b.id).localeCompare(idVersionSortKey(a.id), undefined, { numeric: true }),
+  );
+  return candidates[0];
+}
+
+export type ResolvedPresetModel = {
+  model: ModelInfo;
+  thinking?: string;
+  presetRank: number;
+  presetLabel: string;
+};
+
+export function resolvePresetOrderedModels(
+  models: ModelInfo[],
+  profile: ReviewProfile,
+  priorities: ReviewModelPriorities,
+): ResolvedPresetModel[] {
+  const rows = priorities[profile];
+  const seen = new Set<string>();
+  const out: ResolvedPresetModel[] = [];
+  for (let i = 0; i < rows.length; i++) {
+    const entry = rows[i];
+    const matched = matchPresetEntry(models, entry);
+    if (!matched || seen.has(matched.label)) continue;
+    seen.add(matched.label);
+    out.push({
+      model: matched,
+      thinking: entry.thinking,
+      presetRank: i,
+      presetLabel: entry.idContains,
+    });
+  }
+  return out;
+}
+
+export function rankModelsWithPresets(
+  models: ModelInfo[],
+  profile: ReviewProfile,
+  priorities: ReviewModelPriorities,
+): ModelInfo[] {
+  const preset = resolvePresetOrderedModels(models, profile, priorities);
+  const presetLabels = new Set(preset.map((p) => p.model.label));
+  const rest = models
+    .filter((m) => !presetLabels.has(m.label))
+    .sort((a, b) => a.label.localeCompare(b.label));
+  return [...preset.map((p) => p.model), ...rest];
+}
+
+export function primaryPresetForProfile(
+  models: ModelInfo[],
+  profile: ReviewProfile,
+  priorities: ReviewModelPriorities,
+): ResolvedPresetModel | undefined {
+  return resolvePresetOrderedModels(models, profile, priorities)[0];
+}

package/extensions/rv-prompts.test.ts

@@ -3,6 +3,7 @@ import { describe, it } from "node:test";
 import {
   buildPiReviewArgv,
   buildRvOrchestrationPrompt,
+  orchestrationLocaleNote,
   parseRvArgs,
   validateRvParsed,
 } from "./rv-prompts.js";
@@ -57,6 +58,14 @@ describe("parseRvArgs / validateRvParsed", () => {
     ]);
   });
 
+  it("models orchestration includes locale note and model-selection reference", () => {
+    const p = parseRvArgs("models");
+    const zh = buildRvOrchestrationPrompt(p, "zh");
+    assert.match(zh, /用中文向用户总结/);
+    assert.match(zh, /model-selection/);
+    assert.match(orchestrationLocaleNote("en"), /English/);
+  });
+
   it("orchestration prompt forbids default no-stream and progress-log in Pi", () => {
     const p = parseRvArgs("@src/foo.ts");
     const prompt = buildRvOrchestrationPrompt(p);

package/extensions/rv-prompts.ts

@@ -1,5 +1,8 @@
 /** /rv → parent-agent task text; child review uses resources/review-presets.json */
 
+import type { RvLocale } from "./rv-locale.js";
+import { mergeSemanticIntoParsed, stripSemanticPhrases } from "./rv-semantic.js";
+
 export const RV_MODES = ["code", "plan", "challenge"] as const;
 export type RvMode = (typeof RV_MODES)[number];
 
@@ -21,7 +24,8 @@ export type RvValidation =
   | { ok: false; message: string };
 
 export function parseRvArgs(raw: string): RvParsed {
-  const tokens = raw.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+  const { remainder, apply: semanticApply } = stripSemanticPhrases(raw);
+  const tokens = remainder.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
   const cleaned = tokens.map((t) => t.replace(/^['"]|['"]$/g, ""));
 
   let mode = "code";
@@ -86,16 +90,19 @@ export function parseRvArgs(raw: string): RvParsed {
     rest.push(t);
   }
 
-  return {
-    mode,
-    model,
-    thinking,
-    keepSession,
-    noStream,
-    continueHandle,
-    modelsOnly,
-    target: rest.join(" ").trim(),
-  };
+  return mergeSemanticIntoParsed(
+    {
+      mode,
+      model,
+      thinking,
+      keepSession,
+      noStream,
+      continueHandle,
+      modelsOnly,
+      target: rest.join(" ").trim(),
+    },
+    semanticApply,
+  );
 }
 
 export function validateRvParsed(parsed: RvParsed): RvValidation {
@@ -126,6 +133,13 @@ export function buildPiReviewArgv(parsed: RvParsed, target: string): string[] {
   return parts;
 }
 
+export function orchestrationLocaleNote(locale: RvLocale = "en"): string {
+  if (locale === "zh") {
+    return "用中文向用户总结（模型目录、选型理由、review 结论）；技术 id 如 provider/model 可保留英文。";
+  }
+  return "Summarize for the user in English (catalog, model rationale, review conclusion); keep technical ids such as provider/model as listed.";
+}
+
 function piHostRules(): string {
   return [
     "Follow the pi-review skill.",
@@ -137,13 +151,15 @@ function piHostRules(): string {
   ].join(" ");
 }
 
-export function buildRvOrchestrationPrompt(parsed: RvParsed): string {
+export function buildRvOrchestrationPrompt(parsed: RvParsed, locale: RvLocale = "en"): string {
+  const localeNote = orchestrationLocaleNote(locale);
   if (parsed.modelsOnly) {
     return [
       "Run the pi-review model catalog step.",
       piHostRules(),
+      localeNote,
       "Execute: pi-review models",
-      "Summarize briefly: provider count and 2–3 model IDs that fit code review vs plan/challenge.",
+      "Summarize briefly: provider count and 2–3 model IDs that fit code vs frontend vs plan/challenge (see pi-review skill references/model-selection.md).",
       "Do not start a review until the user supplies a target (@path or text).",
     ].join("\n\n");
   }
@@ -183,8 +199,8 @@ export function buildRvOrchestrationPrompt(parsed: RvParsed): string {
   const modelStep = parsed.model
     ? `Use model exactly as given: ${parsed.model}${parsed.thinking ? ` at thinking ${parsed.thinking}` : ""} (model must appear in pi-review models output).`
     : parsed.thinking
-      ? `Run pi-review models first if needed; pick a suitable listed ID or omit --model for Pi default. Use thinking ${parsed.thinking}.`
-      : "Run pi-review models first if needed; pick a suitable listed ID or omit --model for Pi default.";
+      ? `Run pi-review models first if needed; pick using skill references/model-selection.md (code / frontend / plan) or omit --model for Pi default. Use thinking ${parsed.thinking}.`
+      : "Run pi-review models first if needed; pick using skill references/model-selection.md (code / frontend / plan) or omit --model for Pi default.";
 
   const continueNote = parsed.continueHandle
     ? "Continuing an existing review session. Optional --mode and --model match the same flags as an initial /rv run."
@@ -195,6 +211,7 @@ export function buildRvOrchestrationPrompt(parsed: RvParsed): string {
   return [
     parsed.continueHandle ? "Continue a prior pi-review session." : "Run pi-review for the target below.",
     piHostRules(),
+    localeNote,
     modeBlock[parsed.mode] ??
       `Mode: ${parsed.mode}. Follow the preset named in review-presets.json when present.`,
     modelStep,

package/extensions/rv-semantic.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { parseRvArgs } from "./rv-prompts.js";
+import { stripSemanticPhrases } from "./rv-semantic.js";
+
+describe("stripSemanticPhrases / parseRvArgs", () => {
+  it("maps 方案审核 to plan mode", () => {
+    const p = parseRvArgs("方案审核 @docs/plan.md");
+    assert.equal(p.mode, "plan");
+    assert.equal(p.target, "@docs/plan.md");
+  });
+
+  it("maps list models phrase to modelsOnly", () => {
+    const p = parseRvArgs("查看模型列表");
+    assert.equal(p.modelsOnly, true);
+  });
+
+  it("strips code review before flag parse", () => {
+    const { remainder, apply } = stripSemanticPhrases("code review @src/a.ts");
+    assert.equal(apply.mode, "code");
+    assert.match(remainder, /@src\/a\.ts/);
+  });
+});

package/extensions/rv-semantic.ts

@@ -0,0 +1,110 @@
+/**
+ * Semantic /rv phrases (localized labels, not raw CLI flags in the input box).
+ */
+
+import type { RvParsed } from "./rv-prompts.js";
+import type { RvLocale } from "./rv-locale.js";
+import { rvUi } from "./rv-locale.js";
+
+export type SemanticApply = {
+  mode?: string;
+  keepSession?: boolean;
+  modelsOnly?: boolean;
+  noStream?: boolean;
+};
+
+export type SemanticPhrase = {
+  phrases: string[];
+  apply: SemanticApply;
+  completionValue: (locale: RvLocale) => string;
+  completionDesc?: (locale: RvLocale) => string;
+};
+
+export const SEMANTIC_PHRASES: SemanticPhrase[] = [
+  {
+    phrases: ["code review", "代码审核", "代码审查", "审代码"],
+    apply: { mode: "code" },
+    completionValue: (l) => rvUi(l).modeCode,
+    completionDesc: (l) => (l === "zh" ? "聚焦 diff / 正确性 / 测试" : "Diff, correctness, tests"),
+  },
+  {
+    phrases: ["plan review", "方案审核", "方案评审", "架构审核", "审方案"],
+    apply: { mode: "plan" },
+    completionValue: (l) => rvUi(l).modePlan,
+    completionDesc: (l) => (l === "zh" ? "架构 / 设计 / 产品方案" : "Architecture and design"),
+  },
+  {
+    phrases: ["challenge review", "对抗性审核", "对抗审核", "挑战审核"],
+    apply: { mode: "challenge" },
+    completionValue: (l) => rvUi(l).modeChallenge,
+    completionDesc: (l) => (l === "zh" ? "压力测试假设与风险" : "Adversarial plan pressure-test"),
+  },
+  {
+    phrases: ["keep session for follow-up", "保留会话可追问", "保留会话", "keep session"],
+    apply: { keepSession: true },
+    completionValue: (l) => rvUi(l).keepSession,
+    completionDesc: (l) => rvUi(l).keepSessionDesc,
+  },
+  {
+    phrases: ["list models", "查看模型列表", "模型列表", "list available models"],
+    apply: { modelsOnly: true },
+    completionValue: (l) => rvUi(l).listModels,
+    completionDesc: (l) => rvUi(l).listModelsDesc,
+  },
+];
+
+export function stripSemanticPhrases(raw: string): { remainder: string; apply: SemanticApply } {
+  let remainder = raw;
+  const merged: SemanticApply = {};
+  const sorted = [...SEMANTIC_PHRASES].flatMap((row) =>
+    row.phrases.map((p) => ({ phrase: p, apply: row.apply })),
+  );
+  sorted.sort((a, b) => b.phrase.length - a.phrase.length);
+
+  for (const { phrase, apply } of sorted) {
+    const re = new RegExp(phrase.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+    if (!re.test(remainder)) continue;
+    remainder = remainder.replace(re, " ").replace(/\s+/g, " ").trim();
+    if (apply.mode) merged.mode = apply.mode;
+    if (apply.keepSession) merged.keepSession = true;
+    if (apply.modelsOnly) merged.modelsOnly = true;
+    if (apply.noStream) merged.noStream = true;
+  }
+  return { remainder, apply: merged };
+}
+
+export function mergeSemanticIntoParsed(parsed: RvParsed, apply: SemanticApply): RvParsed {
+  const out = { ...parsed };
+  if (apply.mode) out.mode = apply.mode;
+  if (apply.keepSession) out.keepSession = true;
+  if (apply.modelsOnly) out.modelsOnly = true;
+  if (apply.noStream) out.noStream = true;
+  return out;
+}
+
+export function semanticCompletionItems(
+  locale: RvLocale,
+  tail: string,
+  headPrefix: string,
+  head: string[],
+): { value: string; label: string; description?: string }[] {
+  const present = new Set(head.map((h) => h.toLowerCase()));
+  const q = tail.toLowerCase().trim();
+  const items: { value: string; label: string; description?: string }[] = [];
+  for (const row of SEMANTIC_PHRASES) {
+    const value = row.completionValue(locale);
+    if (present.has(value.toLowerCase())) continue;
+    const matches =
+      !q ||
+      value.toLowerCase().includes(q) ||
+      value.toLowerCase().startsWith(q) ||
+      row.phrases.some((p) => p.toLowerCase().startsWith(q) || p.toLowerCase().includes(q));
+    if (!matches) continue;
+    items.push({
+      value: `${headPrefix}${value}`,
+      label: value,
+      description: row.completionDesc?.(locale),
+    });
+  }
+  return items;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zephyrdeng/pi-review",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Isolated AI-powered code and plan reviews from the command line",
   "type": "module",
   "author": "ZephyrDeng <zephyrTang@aliyun.com>",
@@ -67,8 +67,8 @@
     "build": "tsc",
     "check": "tsc --noEmit",
     "smoke": "node dist/cli.js --help >/dev/null",
-    "test": "npx --yes tsx --test src/child-process.test.ts src/review.meta.test.ts src/meta-footer.test.ts src/json-events.test.ts src/install-args.test.ts extensions/rv-prompts.test.ts extensions/rv-completions.test.ts",
-    "test:rv": "npx --yes tsx --test extensions/rv-prompts.test.ts extensions/rv-completions.test.ts",
+    "test": "npx --yes tsx --test src/child-process.test.ts src/review.meta.test.ts src/meta-footer.test.ts src/json-events.test.ts src/install-args.test.ts extensions/rv-prompts.test.ts extensions/rv-completions.test.ts extensions/rv-model-priorities.test.ts extensions/rv-locale.test.ts extensions/rv-semantic.test.ts",
+    "test:rv": "npx --yes tsx --test extensions/rv-prompts.test.ts extensions/rv-completions.test.ts extensions/rv-model-priorities.test.ts extensions/rv-locale.test.ts extensions/rv-semantic.test.ts",
     "prepublishOnly": "npm run build",
     "pack:dry": "npm pack --dry-run"
   },

package/resources/rv-model-priorities.json

@@ -0,0 +1,17 @@
+{
+  "code": [
+    { "idContains": "gpt-5.5", "thinking": "xhigh" },
+    { "idContains": "glm-5.2", "thinking": "high" }
+  ],
+  "frontend": [
+    { "idContains": "kimi", "versionPrefer": "2.7" },
+    { "idContains": "claude-sonnet", "versionPrefer": "5" },
+    { "idContains": "minimax-m3" }
+  ],
+  "plan": [
+    { "idContains": "claude-opus-4-8" },
+    { "idContains": "claude-opus-4", "versionPrefer": "8" },
+    { "idContains": "deepseek-v4-pro" },
+    { "idContains": "deepseek-v4" }
+  ]
+}

package/skills/pi-review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pi-review
-description: Use pi-review to delegate isolated code, diff, repository, architecture, or plan reviews to a fresh Pi session and return only the review conclusion. On Claude Code or Codex, default to --progress-log with a background shell run and tail the log (chat tools buffer stdout). Use when the user asks for Pi review, isolated review, code review, plan review, challenge review, review status/progress, or wants to avoid context pollution.
+description: Use pi-review to delegate isolated code, diff, repository, architecture, or plan reviews to a fresh Pi session and return only the review conclusion. Model selection presets for code, frontend, and plan review (see references/model-selection.md). On Claude Code or Codex, default to --progress-log with a background shell run and tail the log (chat tools buffer stdout). Use when the user asks for Pi review, isolated review, code review, plan review, challenge review, review status/progress, or wants to avoid context pollution.
 ---
 
 # Pi Review
@@ -26,7 +26,8 @@ When resolving this fallback, use the actual directory that contains this `SKILL
 ## Codex / Claude Code
 
 - Map skill mentions of `Bash` to your host shell tool.
-- Read **[references/codex-tools.md](./references/codex-tools.md)** (next to this `SKILL.md`) for Codex/Claude Code defaults: `--progress-log` + background run + tail.
+- Read **[references/codex-tools.md](./references/codex-tools.md)** for `--progress-log` + background run + tail.
+- Read **[references/model-selection.md](./references/model-selection.md)** when choosing `--model` after `pi-review models` (code / frontend / plan presets).
 - Do not use a blocking foreground shell alone for live progress; follow **Default workflow by host** below.
 
 ## Default workflow by host
@@ -79,15 +80,17 @@ Do not implement findings from a status check; status is informational only.
 
 ## Steps
 
-1. Prime the model catalog:
+1. Prime the model catalog and pick a model:
    ```bash
    pi-review models [search]
    ```
    Rules:
    - Run this before building the review command.
-   - If the user named a model, use that provider/model text as `[search]` and verify the exact ID from the output.
-   - If the user did not name a model, run `pi-review models` and either choose an exact suitable ID from the output or deliberately omit `--model` to use Pi's default.
-   Completion criterion: the model choice is either an exact listed `provider/model[:thinking]` or an explicit decision to use Pi's default.
+   - If the user named a model, use that text as `[search]` and verify the **exact** listed `provider/model` from the output.
+   - If the user did not name a model, follow **[references/model-selection.md](./references/model-selection.md)**: infer profile (code / frontend / plan), match the priority list against catalog ids, then set `--model` with optional `:thinking` when supported.
+   - On **Claude Code / Codex / Cursor**, state the chosen model in one line (match the user's language) before running the review command.
+   - If nothing in the priority list matches, omit `--model` (Pi default) or pick a listed reasoning model with large context—say which and why.
+   Completion criterion: exact listed `provider/model[:thinking]` or an explicit default; never invented ids.
 
 2. Choose one mode:
    - default `code` — code, diff, MR, file, or repository review.

package/skills/pi-review/references/codex-tools.md

@@ -25,6 +25,8 @@ When the **pi-review** skill applies on Codex, Claude Code, or Cursor:
 
 See the parent skill: sections *Default workflow by host* and *Streaming vs agent hosts (Claude Code / Codex)*.
 
+**Model choice:** after `pi-review models`, use **[model-selection.md](./model-selection.md)** (code / frontend / plan presets)—same guidance as Pi `/rv` completions.
+
 Example tail (milestone events only):
 
 ```bash

package/skills/pi-review/references/model-selection.md

@@ -0,0 +1,72 @@
+# Model selection for pi-review (all hosts)
+
+Use this after `pi-review models` (or `pi-review models <search>`). **Never invent** `provider/model` IDs—only IDs that appear in that output.
+
+## Workflow (Claude Code, Codex, Cursor, Pi parent agent)
+
+1. Run `pi-review models` (narrow with search if the user named a vendor or model family).
+2. Infer **review profile** from the target (see table below).
+3. Walk the **priority list** for that profile; pick the **first** row whose `idContains` matches some listed model id (case-insensitive substring). If several ids match one row, prefer the **newest** id (higher version suffix, e.g. `2.7` over `2.5`, `4-8` over `4-6`).
+4. Set `--model <exact-listed-provider/model>` from the catalog. Add `:thinking` only if that model supports it in Pi and the preset suggests it (see thinking column).
+5. If **no** priority row matches anything in the catalog, either omit `--model` (Pi default) or pick the best **reasoning** model with a large context window from the list—state the choice in one line to the user.
+
+## Profiles
+
+| Profile | When to use |
+|---------|-------------|
+| **code** | Default: diffs, MRs, backend/ general code paths (`@src/...`, `.ts`, `.go`, …). |
+| **frontend** | UI-heavy targets: `.vue`, `.svelte`, `.css`, `.scss`, `.html`, or user says frontend / UI / multimodal. |
+| **plan** | `--mode plan` or `--mode challenge`, or reviewing `.md` / design / architecture docs (not line-by-line code only). |
+
+## Priority lists (same as Pi `/rv` package preset)
+
+Configurable on disk for Pi: `resources/rv-model-priorities.json` or `PI_REVIEW_RV_PRIORITIES`. Agents should follow this table unless the user overrides.
+
+### Code review
+
+| Order | Match model id containing | Suggested thinking |
+|-------|---------------------------|------------------|
+| 1 | `gpt-5.5` | `xhigh` |
+| 2 | `glm-5.2` | `high` |
+
+### Frontend / multimodal review
+
+| Order | Match model id containing | Notes |
+|-------|---------------------------|--------|
+| 1 | `kimi` | Prefer id that also contains `2.7` when multiple Kimi ids exist |
+| 2 | `claude-sonnet` | Prefer id containing `5` when multiple |
+| 3 | `minimax-m3` | Multimodal-friendly |
+
+Use **code** mode (`pi-review` default) unless the user asked for plan/challenge.
+
+### Plan / challenge review
+
+| Order | Match model id containing |
+|-------|---------------------------|
+| 1 | `claude-opus-4-8` |
+| 2 | `claude-opus-4` (+ prefer `8` in id if several) |
+| 3 | `deepseek-v4-pro` |
+| 4 | `deepseek-v4` |
+
+Use `--mode plan` or `--mode challenge` as appropriate.
+
+## Examples (illustrative—always substitute exact catalog strings)
+
+```bash
+# Code
+pi-review --model openai-codex/gpt-5.5:xhigh -- @src/auth.ts
+
+# Frontend
+pi-review --model wafer.ai/Kimi-K2.6 -- @src/App.vue
+
+# Plan
+pi-review --mode plan --model px:anthropic/claude-opus-4-8 -- @docs/architecture.md
+```
+
+## User-named model
+
+If the user specifies a model, run `pi-review models <fragment>` and use the **exact** listed id. Do not normalize or guess provider prefixes.
+
+## Language
+
+Explain your model choice briefly in the **same language** as the user's request (Chinese ↔ English). The review body language is independent; this rule is only for the one-line rationale before/after invoking `pi-review`.