@zephyrdeng/pi-review 0.6.0 → 0.6.2

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,14 +169,29 @@ 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(" @"));
   });
 
+  it("does not duplicate list-models completion at top level", () => {
+    for (const locale of ["en", "zh"] as const) {
+      for (const prefix of ["", "models", "list", "mod"]) {
+        const items = buildRvCompletions(prefix, { ...deps, locale });
+        if (!items?.length) continue;
+        const ui = rvUi(locale);
+        const listModelItems = items.filter((i) => i.label === ui.listModels);
+        assert.ok(
+          listModelItems.length <= 1,
+          `locale=${locale} prefix=${JSON.stringify(prefix)} got ${listModelItems.length} "${ui.listModels}" items`,
+        );
+      }
+    }
+  });
+
   it("every returned value preserves the head prefix (整段替换安全)", () => {
     const cases = ["@a.ts --mode ", "@a.ts --model ", "@a.ts --thinking ", "@a.ts --"];
     for (const c of cases) {
@@ -202,15 +217,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,31 @@ 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));
+  const hasListModelsItem = items.some((i) => i.label === ui.listModels);
+  if (
+    !hasListModelsItem &&
+    (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 +463,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");
+  });
+});