@zephyrdeng/pi-review 0.5.1 → 0.6.1

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";
@@ -42,6 +43,29 @@ describe("parseRvArgs / validateRvParsed", () => {
     ]);
   });
 
+  it("parses --thinking and threads it into CLI argv", () => {
+    const p = parseRvArgs("--thinking xhigh --model openai/gpt-5.5 @x.md");
+    assert.equal(p.thinking, "xhigh");
+    assert.equal(p.model, "openai/gpt-5.5");
+    assert.deepEqual(buildPiReviewArgv(p, "@x.md"), [
+      "pi-review",
+      "--model",
+      "openai/gpt-5.5",
+      "--thinking",
+      "xhigh",
+      "--",
+      "@x.md",
+    ]);
+  });
+
+  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,13 +1,17 @@
 /** /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];
 
-const FLAGS_REQUIRING_VALUE = ["--mode", "--model", "--continue"] as const;
+const FLAGS_REQUIRING_VALUE = ["--mode", "--model", "--thinking", "--continue"] as const;
 
 export type RvParsed = {
   mode: string;
   model?: string;
+  thinking?: string;
   keepSession: boolean;
   noStream: boolean;
   continueHandle?: string;
@@ -20,11 +24,13 @@ 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";
   let model: string | undefined;
+  let thinking: string | undefined;
   let keepSession = false;
   let noStream = false;
   let continueHandle: string | undefined;
@@ -63,6 +69,15 @@ export function parseRvArgs(raw: string): RvParsed {
       model = cleaned[++i];
       continue;
     }
+    if (t === "--thinking") {
+      const v = cleaned[i + 1];
+      if (!v || v.startsWith("--")) {
+        rest.push(t);
+        continue;
+      }
+      thinking = cleaned[++i];
+      continue;
+    }
     if (t === "--continue") {
       const v = cleaned[i + 1];
       if (!v || v.startsWith("--")) {
@@ -75,15 +90,19 @@ export function parseRvArgs(raw: string): RvParsed {
     rest.push(t);
   }
 
-  return {
-    mode,
-    model,
-    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 {
@@ -108,11 +127,19 @@ export function buildPiReviewArgv(parsed: RvParsed, target: string): string[] {
   }
   if (parsed.mode !== "code") parts.push("--mode", parsed.mode);
   if (parsed.model) parts.push("--model", parsed.model);
+  if (parsed.thinking) parts.push("--thinking", parsed.thinking);
   if (parsed.noStream) parts.push("--no-stream");
   parts.push("--", target);
   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.",
@@ -124,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");
   }
@@ -168,8 +197,10 @@ export function buildRvOrchestrationPrompt(parsed: RvParsed): string {
   const cliLine = buildPiReviewArgv(parsed, target).join(" ");
 
   const modelStep = parsed.model
-    ? `Use model exactly as given: ${parsed.model} (must appear in pi-review models output).`
-    : "Run pi-review models first if needed; pick a suitable listed ID or omit --model for Pi default.";
+    ? `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 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."
@@ -180,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,
@@ -197,6 +229,7 @@ export const RV_COMPLETIONS: { value: string; hint: string }[] = [
   { value: "--mode plan", hint: "architecture or plan review" },
   { value: "--mode challenge", hint: "adversarial plan review" },
   { value: "--model ", hint: "provider/model from pi-review models" },
+  { value: "--thinking ", hint: "off|minimal|low|medium|high|xhigh" },
   { value: "--keep-session", hint: "persist session for follow-up" },
   { value: "--no-stream", hint: "rare: buffer until exit (not default in Pi)" },
   { value: "--continue ", hint: "resume session; same optional flags as initial /rv" },

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.5.1",
+  "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",
-    "test:rv": "npx --yes tsx --test extensions/rv-prompts.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`.