@zephyrdeng/pi-review 0.7.1 → 0.8.1

package/extensions/rv-interactive.ts

@@ -0,0 +1,616 @@
+/**
+ * Interactive /rv and /rv-loop wizard using Pi dialog APIs (select/input/confirm).
+ * Pure orchestration over injected UI so it is unit-testable without a TUI.
+ */
+
+import type { ModelInfo } from "./rv-completions.js";
+import type { RvLocale } from "./rv-locale.js";
+import { rvUi } from "./rv-locale.js";
+import {
+  MODEL_PICKER_SKIP,
+  type ModelPickerResult,
+} from "./rv-model-picker.js";
+import {
+  RV_CLEAN_GOAL,
+  RV_CONSENSUS_POLICIES,
+  RV_LOOP_DEFAULT_MAX_ROUNDS,
+  RV_LOOP_UNTIL_CLEAN_DEFAULT_MAX_ROUNDS,
+  type RvConsensusPolicy,
+  type RvParsed,
+  type RvStrategy,
+} from "./rv-prompts.js";
+import {
+  DEFAULT_REVIEW_MODEL_PRIORITIES,
+  loadReviewModelPriorities,
+  rankModelsWithPresets,
+  resolveReviewProfile,
+  type ReviewProfile,
+} from "./rv-model-priorities.js";
+
+export type CustomModelPickerInput = {
+  /** Models already ranked for the active mode (presets first). */
+  ranked: ModelInfo[];
+  locale: RvLocale;
+  allowSkip: boolean;
+  title: string;
+};
+
+export type InteractiveUi = {
+  select: (title: string, options: string[]) => Promise<string | undefined>;
+  input: (title: string, placeholder?: string) => Promise<string | undefined>;
+  confirm: (title: string, message: string) => Promise<boolean>;
+  notify: (message: string, type?: "info" | "warning" | "error") => void;
+  /** Inline searchable model picker (TUI only). When present, the wizard uses
+   *  it instead of the select-based flow. Returns a label, `MODEL_PICKER_SKIP`,
+   *  or `undefined` (cancel). */
+  customModelPicker?: (input: CustomModelPickerInput) => Promise<ModelPickerResult>;
+};
+
+export type InteractiveWizardInput = {
+  strategy: Exclude<RvStrategy, "models">;
+  /** Already-parsed partial from the command line (flags + optional target). */
+  seed: RvParsed;
+  models: ModelInfo[];
+  locale: RvLocale;
+  primaryProvider?: string;
+};
+
+const CANCEL = Symbol("cancel");
+
+function profileFor(mode: string): ReviewProfile {
+  return resolveReviewProfile(mode);
+}
+
+function rankedModelLabels(models: ModelInfo[], mode: string): string[] {
+  if (models.length === 0) return [];
+  const profile = profileFor(mode);
+  const priorities = loadReviewModelPriorities();
+  return rankModelsWithPresets(models, profile, priorities).map((m) => m.label);
+}
+
+function modelByLabel(models: ModelInfo[], label: string): ModelInfo | undefined {
+  return models.find((m) => m.label === label);
+}
+
+function thinkingOptions(model: ModelInfo | undefined, locale: RvLocale): string[] {
+  const levels = model?.thinkingLevels?.length ? model.thinkingLevels : ["high", "xhigh", "medium", "low", "off"];
+  const skip = locale === "zh" ? "跳过（默认）" : "Skip (default)";
+  return [skip, ...levels];
+}
+
+function stripSkip(choice: string | undefined, locale: RvLocale): string | undefined {
+  if (!choice) return undefined;
+  if (choice.startsWith("Skip") || choice.startsWith("跳过")) return undefined;
+  return choice;
+}
+
+async function mustSelect(ui: InteractiveUi, title: string, options: string[]): Promise<string | typeof CANCEL> {
+  if (options.length === 0) return CANCEL;
+  const choice = await ui.select(title, options);
+  return choice ?? CANCEL;
+}
+
+/** At or below this model count, the wizard shows a simple flat ranked list.
+ *  Above it, the flat list gets hard to navigate, so the wizard first offers a
+ *  provider browser and a search box (Pi's `select` dialog has no built-in
+ *  search or grouping, so we compose it from `select` + `input`). */
+const MODEL_PICKER_THRESHOLD = 8;
+
+/** Case-insensitive, separator-insensitive match used by the search path.
+ *  Mirrors the completion matcher so "gpt55", "gpt-5.5", "openai/gpt-5.5" all hit. */
+function modelMatchesQuery(m: ModelInfo, query: string): boolean {
+  const q = query.toLowerCase();
+  const label = m.label.toLowerCase();
+  const id = m.id.toLowerCase();
+  const provider = m.provider.toLowerCase();
+  const labelKey = label.replace(/[^a-z0-9/]+/g, "");
+  const idKey = id.replace(/[^a-z0-9]+/g, "");
+  const qKey = q.replace(/[^a-z0-9/]+/g, "");
+  return (
+    label.startsWith(q) ||
+    label.includes(q) ||
+    id.startsWith(q) ||
+    provider.startsWith(q) ||
+    provider.includes(q) ||
+    labelKey.includes(qKey) ||
+    idKey.includes(qKey.replace(/\//g, ""))
+  );
+}
+
+function rankedModels(models: ModelInfo[], mode: string): ModelInfo[] {
+  if (models.length === 0) return [];
+  return rankModelsWithPresets(models, profileFor(mode), loadReviewModelPriorities());
+}
+
+/**
+ * Pick a model label through dialogs.
+ * @returns the chosen label; `CANCEL` if the user escapes; `undefined` if they pick skip.
+ *
+ * With few models this is a flat ranked list (optionally with a Skip entry).
+ * With many models it first asks how to pick — browse by provider, search, or
+ * the full ranked list — so a long catalog stays navigable without scrolling
+ * dozens of rows.
+ */
+async function pickModelLabel(
+  ui: InteractiveUi,
+  models: ModelInfo[],
+  mode: string,
+  locale: RvLocale,
+  title: string,
+  allowSkip: boolean,
+): Promise<string | typeof CANCEL | undefined> {
+  const zh = locale === "zh";
+  const ranked = rankedModels(models, mode);
+  if (ranked.length === 0) return CANCEL;
+
+  // Inline searchable picker (TUI only) — one box, live fuzzy filter, Tab to
+  // cycle provider scope. Preferred over the select-based flow whenever the
+  // host provides it; print/RPC modes have no `custom` and fall through.
+  if (ui.customModelPicker) {
+    const result = await ui.customModelPicker({ ranked, locale, allowSkip, title });
+    if (result === undefined) return CANCEL; // user cancelled (Esc)
+    if (result === MODEL_PICKER_SKIP) return undefined; // skip (Pi default)
+    return result; // chosen label
+  }
+
+  const labels = ranked.map((m) => m.label);
+  const skipOption = allowSkip ? [zh ? "跳过（用 Pi 默认）" : "Skip (Pi default)"] : [];
+
+  // Simple case: small catalog — flat ranked list, optionally with skip.
+  if (ranked.length <= MODEL_PICKER_THRESHOLD) {
+    const pick = await mustSelect(ui, title, [...skipOption, ...labels]);
+    if (pick === CANCEL) return CANCEL;
+    return stripSkip(pick, locale);
+  }
+
+  // Many models — offer provider browse / search / full ranked list.
+  const methodOptions = [
+    zh ? "按 provider 浏览（↑↓ 切换 provider，回车进入模型）" : "Browse by provider (arrows switch provider, enter drills in)",
+    zh ? "搜索模型（输入 provider 或 model 关键词）" : "Search models (type a provider or model keyword)",
+    zh ? "按推荐排序查看全部" : "Ranked list (all models)",
+    ...skipOption,
+  ];
+  const method = await mustSelect(ui, title, methodOptions);
+  if (method === CANCEL) return CANCEL;
+  if (allowSkip && stripSkip(method, locale) === undefined) return undefined;
+
+  // Dispatch by stable prefix — the search option text mentions "provider" as a
+  // hint, so check Search before the provider branch to avoid misrouting.
+  if (method.startsWith("Search") || method.startsWith("搜索")) {
+    return searchModel(ui, ranked, locale, title);
+  }
+  if (method.startsWith("Browse") || method.startsWith("按 provider")) {
+    return browseByProvider(ui, ranked, locale, title);
+  }
+  // Ranked list (all) — show every model; Escape to cancel.
+  const allPick = await mustSelect(ui, title, labels);
+  if (allPick === CANCEL) return CANCEL;
+  return allPick;
+}
+
+/** Provider browser: pick a provider, then a model under it. The model list
+ *  includes a "← Switch provider" entry so the user can jump back and pick an
+ *  adjacent provider (the closest affordance to left/right switching that the
+ *  flat `select` dialog supports). The previously chosen provider is marked
+ *  with ▸ so the user sees where they were. */
+async function browseByProvider(
+  ui: InteractiveUi,
+  ranked: ModelInfo[],
+  locale: RvLocale,
+  title: string,
+): Promise<string | typeof CANCEL> {
+  const zh = locale === "zh";
+  const byProvider = new Map<string, ModelInfo[]>();
+  for (const m of ranked) {
+    const list = byProvider.get(m.provider) ?? [];
+    list.push(m);
+    byProvider.set(m.provider, list);
+  }
+  // Biggest vendors first, then alphabetical — keeps the common providers near the top.
+  const providers = [...byProvider.entries()].sort(
+    (a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0]),
+  );
+
+  let lastIdx = 0;
+  for (;;) {
+    const providerOptions = providers.map(([p, list], i) => {
+      const marker = i === lastIdx ? "▸ " : "  ";
+      return `${marker}${p} (${list.length})`;
+    });
+    const provPick = await mustSelect(
+      ui,
+      zh ? `${title} · 选择 provider（↑↓ 切换，回车进入）` : `${title} · pick provider (arrows to switch)`,
+      providerOptions,
+    );
+    if (provPick === CANCEL) return CANCEL;
+    const idx = Math.max(0, providerOptions.indexOf(provPick));
+    lastIdx = idx;
+    const provider = providers[idx][0];
+    const modelLabels = providers[idx][1].map((m) => m.label);
+
+    const backEntry = zh ? "← 切换 provider" : "← Switch provider";
+    const modelPick = await mustSelect(
+      ui,
+      zh ? `${title} · ${provider}（共 ${modelLabels.length} 个）` : `${title} · ${provider} (${modelLabels.length} models)`,
+      [backEntry, ...modelLabels],
+    );
+    if (modelPick === CANCEL) return CANCEL;
+    if (modelPick === backEntry) continue;
+    return modelPick;
+  }
+}
+
+/** Search flow: type a keyword, then pick from the filtered list. The filtered
+ *  list includes a "← Search again" entry; empty matches notify and re-prompt. */
+async function searchModel(
+  ui: InteractiveUi,
+  ranked: ModelInfo[],
+  locale: RvLocale,
+  title: string,
+): Promise<string | typeof CANCEL> {
+  const zh = locale === "zh";
+  for (;;) {
+    const q = await ui.input(
+      zh
+        ? `${title} · 搜索（provider 或 model 关键词，回车=显示全部）`
+        : `${title} · search (provider or model keyword; enter = all)`,
+      zh ? "例如：claude / gpt / anthropic" : "e.g. claude / gpt / anthropic",
+    );
+    if (q === undefined) return CANCEL; // user escaped the input
+    const query = q.trim().toLowerCase();
+    const filtered = query ? ranked.filter((m) => modelMatchesQuery(m, query)) : ranked;
+    if (filtered.length === 0) {
+      ui.notify(
+        zh ? `没有匹配 "${query}" 的模型，请换个关键词` : `No models match "${query}"; try another keyword`,
+        "warning",
+      );
+      continue;
+    }
+    const backEntry = zh ? "← 重新搜索" : "← Search again";
+    const labels = filtered.map((m) => m.label);
+    const pick = await mustSelect(
+      ui,
+      zh ? `${title} · 搜索结果（${labels.length} 个）` : `${title} · results (${labels.length})`,
+      [backEntry, ...labels],
+    );
+    if (pick === CANCEL) return CANCEL;
+    if (pick === backEntry) continue;
+    return pick;
+  }
+}
+
+/**
+ * Build a fully populated RvParsed via dialogs.
+ * Returns undefined if the user cancels any required step.
+ */
+export async function runRvInteractiveWizard(
+  ui: InteractiveUi,
+  input: InteractiveWizardInput,
+): Promise<RvParsed | undefined> {
+  const { strategy, seed, models, locale } = input;
+  const zh = locale === "zh";
+  const uiText = rvUi(locale);
+
+  // 1) Mode. This drives the model profile, so choose it before target/model input.
+  let mode = seed.mode || "code";
+  if (!seed.mode || seed.mode === "code") {
+    const modeChoice = await mustSelect(
+      ui,
+      zh ? "审查模式" : "Review mode",
+      [
+        `${uiText.modeCode} (code)`,
+        `${uiText.modePlan} (plan)`,
+        `${uiText.modeChallenge} (challenge)`,
+      ],
+    );
+    if (modeChoice === CANCEL) return undefined;
+    if (modeChoice.includes("(plan)")) mode = "plan";
+    else if (modeChoice.includes("(challenge)")) mode = "challenge";
+    else mode = "code";
+  }
+
+  // 2) Target. Collect it after mode so the flow starts with review intent.
+  let target = seed.target.trim();
+  if (!target) {
+    const entered = await ui.input(
+      zh ? "审查目标（自然语言或 @路径）" : "Review target (natural language or @path)",
+      zh ? "例如：@src 或 review the auth changes" : "e.g. @src or review the auth changes",
+    );
+    if (!entered?.trim()) {
+      ui.notify(zh ? "已取消：需要审查目标" : "Cancelled: target required", "warning");
+      return undefined;
+    }
+    target = entered.trim();
+  }
+
+  // 3) Loop goal + hard budget — always ask for /rv-loop so the stop condition is explicit.
+  let until = seed.until;
+  let maxRounds = seed.maxRounds;
+  if (strategy === "loop") {
+    const goal = await mustSelect(
+      ui,
+      zh ? "Loop 目标" : "Loop goal",
+      [
+        zh
+          ? "单轮门禁（修完再手动 /rv-loop）· 推荐"
+          : "Single gate (fix then re-run /rv-loop) · recommended",
+        zh
+          ? "until clean · 审→修→再审直到 clean（有硬预算）"
+          : "until clean · review→fix→re-review until clean (hard budget)",
+      ],
+    );
+    if (goal === CANCEL) return undefined;
+    if (goal.includes("until clean")) {
+      until = "clean";
+      const current = maxRounds ?? RV_LOOP_UNTIL_CLEAN_DEFAULT_MAX_ROUNDS;
+      const budget = await mustSelect(
+        ui,
+        zh
+          ? `until-clean 硬预算 max-rounds（当前 ${current}）· 不是无限`
+          : `until-clean hard budget max-rounds (current ${current}) · not unlimited`,
+        [
+          zh ? `5 · 最多 5 个 host 周期` : `5 · up to 5 host cycles`,
+          zh ? `10 · 默认` : `10 · default`,
+          zh ? `15 · 更长` : `15 · longer`,
+          zh ? `20 · 上限偏松` : `20 · looser cap`,
+        ].sort((a, b) => (Number(a.split(" · ")[0]) === current ? -1 : Number(b.split(" · ")[0]) === current ? 1 : 0)),
+      );
+      if (budget === CANCEL) return undefined;
+      maxRounds = Number(budget.split(" · ")[0]) || RV_LOOP_UNTIL_CLEAN_DEFAULT_MAX_ROUNDS;
+    } else {
+      until = undefined;
+      const current = maxRounds ?? RV_LOOP_DEFAULT_MAX_ROUNDS;
+      const options = [
+        zh ? `1 · 修一次再审（推荐）` : `1 · host fix point (recommended)`,
+        zh ? `2 · 两轮` : `2 · two gates`,
+        zh ? `3 · 三轮` : `3 · three gates`,
+      ];
+      const ordered = [...options].sort((a, b) => {
+        const av = Number(a[0]) === current ? 0 : 1;
+        const bv = Number(b[0]) === current ? 0 : 1;
+        return av - bv;
+      });
+      const rounds = await mustSelect(
+        ui,
+        zh
+          ? `审查轮数 max-rounds（当前 ${current}）· 与 reviewers 人数无关`
+          : `Review rounds max-rounds (current ${current}) · not reviewer count`,
+        ordered,
+      );
+      if (rounds === CANCEL) return undefined;
+      maxRounds = Number(rounds[0]) || RV_LOOP_DEFAULT_MAX_ROUNDS;
+    }
+  }
+
+  // 4) Panel shape: preset vs N reviewers
+  let panel = seed.panel;
+  let reviewers = seed.reviewers;
+  const reviewerModels = [...(seed.reviewerModels ?? [])];
+
+  if (!panel && reviewers === undefined) {
+    const shape = await mustSelect(
+      ui,
+      zh ? "Panel 形态" : "Panel shape",
+      [
+        zh ? "预设 code-experts（正确性/安全/测试）" : "Preset code-experts (correctness/security/testing)",
+        zh ? "自定义人数 2–8（r1..rN，可逐个选模型）" : "Custom reviewer count 2–8 (r1..rN, pick models)",
+        // Single-reviewer is a different product path (no panel). Keep it explicit and rare.
+        zh ? "单 reviewer 非 panel（无共识，仅 shell 单审查）" : "Single reviewer non-panel (no consensus; shell single review)",
+      ],
+    );
+    if (shape === CANCEL) return undefined;
+    if (shape.includes("code-experts") || shape.includes("Preset")) {
+      panel = "code-experts";
+    } else if (shape.includes("non-panel") || shape.includes("非 panel") || shape.includes("Single reviewer non-panel")) {
+      // Explicit non-panel single review. Parent must use shell CLI, not pi_review panel tool.
+      reviewers = 1;
+      panel = undefined;
+    } else {
+      const countChoice = await mustSelect(
+        ui,
+        zh ? "独立 reviewer 人数（宽度，≥2 才是 panel）" : "Independent reviewers (width, panel requires ≥2)",
+        ["2", "3", "4", "5"],
+      );
+      if (countChoice === CANCEL) return undefined;
+      reviewers = Number(countChoice);
+    }
+  }
+
+  // Keep reviewers=1 explicit: orchestration uses it to select the non-panel shell path.
+  // Collapsing it to undefined would be indistinguishable from the default code-experts panel.
+
+  // 5) Per-reviewer models via select dialogs (no tab completion)
+  const ids =
+    panel === "code-experts"
+      ? ["correctness", "security", "testing"]
+      : reviewers && reviewers > 1
+        ? Array.from({ length: reviewers }, (_, i) => `r${i + 1}`)
+        : [];
+
+  const labels = rankedModelLabels(models, mode);
+
+  if (ids.length > 0) {
+    const assignEach = await ui.confirm(
+      zh ? "为每位 reviewer 选择模型？" : "Pick a model for each reviewer?",
+      zh
+        ? `将依次为 ${ids.join(", ")} 弹出模型列表（方向键选择，回车确认）。选「同一模型」可共用。`
+        : `You will pick models for ${ids.join(", ")} from a list (arrows + enter). Choose "Same model for all" to share.`,
+    );
+
+    if (assignEach) {
+      const sameFirst = await mustSelect(
+        ui,
+        zh ? "模型分配方式" : "Model assignment",
+        [
+          zh ? "每位 reviewer 分别选择" : "Pick separately for each reviewer",
+          zh ? "所有 reviewer 使用同一模型" : "Same model for all reviewers",
+        ],
+      );
+      if (sameFirst === CANCEL) return undefined;
+
+      if (sameFirst.includes("Same") || sameFirst.includes("同一")) {
+        if (labels.length === 0) {
+          ui.notify(zh ? "当前没有可用模型目录，请先 /rv-models" : "No model catalog available; run /rv-models first", "warning");
+        } else {
+          const pick = await pickModelLabel(ui, models, mode, locale, zh ? "共用模型" : "Shared model", false);
+          if (pick === CANCEL) return undefined;
+          if (pick !== undefined) {
+            const m = modelByLabel(models, pick);
+            const thinkingPick = await mustSelect(
+              ui,
+              zh ? `思考强度（${pick}）` : `Thinking (${pick})`,
+              thinkingOptions(m, locale),
+            );
+            if (thinkingPick === CANCEL) return undefined;
+            const thinking = stripSkip(thinkingPick, locale);
+            const token = thinking ? `${pick}:${thinking}` : pick;
+            for (const id of ids) reviewerModels.push(`${id}=${token}`);
+          }
+        }
+      } else {
+        for (const id of ids) {
+          if (labels.length === 0) break;
+          const pick = await pickModelLabel(ui, models, mode, locale, zh ? `模型 · ${id}` : `Model · ${id}`, false);
+          if (pick === CANCEL) return undefined;
+          if (pick === undefined) continue; // defensive: allowSkip=false never returns undefined here
+          const m = modelByLabel(models, pick);
+          const thinkingPick = await mustSelect(
+            ui,
+            zh ? `思考强度 · ${id}` : `Thinking · ${id}`,
+            thinkingOptions(m, locale),
+          );
+          if (thinkingPick === CANCEL) return undefined;
+          const thinking = stripSkip(thinkingPick, locale);
+          reviewerModels.push(`${id}=${thinking ? `${pick}:${thinking}` : pick}`);
+        }
+      }
+    } else if (!seed.model && labels.length > 0) {
+      // Shared default model when not assigning per-reviewer
+      const pick = await pickModelLabel(ui, models, mode, locale, zh ? "默认模型（全体 reviewer）" : "Default model (all reviewers)", true);
+      if (pick === CANCEL) return undefined;
+      if (pick !== undefined) {
+        const m = modelByLabel(models, pick);
+        const thinkingPick = await mustSelect(
+          ui,
+          zh ? "默认思考强度" : "Default thinking",
+          thinkingOptions(m, locale),
+        );
+        if (thinkingPick === CANCEL) return undefined;
+        const thinking = stripSkip(thinkingPick, locale);
+        seed.model = pick;
+        if (thinking) seed.thinking = thinking;
+      }
+    }
+  } else if (!seed.model && labels.length > 0) {
+    // Single-reviewer path
+    const pick = await pickModelLabel(ui, models, mode, locale, zh ? "模型" : "Model", true);
+    if (pick === CANCEL) return undefined;
+    if (pick !== undefined) {
+      seed.model = pick;
+      const m = modelByLabel(models, pick);
+      const thinkingPick = await mustSelect(ui, zh ? "思考强度" : "Thinking", thinkingOptions(m, locale));
+      if (thinkingPick === CANCEL) return undefined;
+      const thinking = stripSkip(thinkingPick, locale);
+      if (thinking) seed.thinking = thinking;
+    }
+  }
+
+  // 6) Consensus when multi-reviewer
+  let consensus = seed.consensus;
+  let minAgree = seed.minAgree;
+  if ((panel || (reviewers ?? 0) > 1) && !consensus) {
+    const c = await mustSelect(
+      ui,
+      zh ? "共识策略" : "Consensus policy",
+      RV_CONSENSUS_POLICIES.map((p) => {
+        if (p === "quorum") return zh ? "quorum · 至少 min-agree 人同意（默认）" : "quorum · at least min-agree agree (default)";
+        if (p === "majority") return zh ? "majority · 过半数" : "majority · floor(n/2)+1";
+        if (p === "unanimous") return zh ? "unanimous · 全员同意" : "unanimous · all must agree";
+        return zh ? "any · 任一即可" : "any · single actionable reviewer";
+      }),
+    );
+    if (c === CANCEL) return undefined;
+    consensus = c.split(" · ")[0] as RvConsensusPolicy;
+    if (consensus === "quorum" && minAgree === undefined) {
+      const m = await mustSelect(
+        ui,
+        zh ? "quorum 最少同意人数" : "Quorum min-agree",
+        ["2", "3", "4"],
+      );
+      if (m === CANCEL) return undefined;
+      minAgree = Number(m);
+    }
+  }
+
+  // 7) Confirm summary
+  const summaryLines = [
+    `${zh ? "策略" : "Strategy"}: ${strategy}`,
+    `${zh ? "目标" : "Target"}: ${target}`,
+    `${zh ? "模式" : "Mode"}: ${mode}`,
+    strategy === "loop"
+      ? until === "clean"
+        ? `${zh ? "目标" : "Goal"}: until clean · budget ${maxRounds ?? RV_LOOP_UNTIL_CLEAN_DEFAULT_MAX_ROUNDS}\n${zh ? "Clean 定义" : "Clean means"}: ${RV_CLEAN_GOAL.summary}`
+        : `${zh ? "审查轮数 max-rounds" : "Review rounds max-rounds"}: ${maxRounds ?? RV_LOOP_DEFAULT_MAX_ROUNDS}`
+      : `${zh ? "审查轮数" : "Review rounds"}: 1 (${zh ? "/rv 单次 panel，无 loop" : "/rv is a single panel gate"})`,
+    panel
+      ? `panel: ${panel}`
+      : reviewers
+        ? `${zh ? "每轮 reviewers" : "reviewers per round"}: ${reviewers}`
+        : zh
+          ? "单 reviewer"
+          : "single reviewer",
+    seed.model ? `model: ${seed.model}${seed.thinking ? `:${seed.thinking}` : ""}` : "",
+    reviewerModels.length ? `reviewer-models: ${reviewerModels.join(", ")}` : "",
+    consensus ? `consensus: ${consensus}${minAgree ? ` min-agree=${minAgree}` : ""}` : "",
+  ].filter(Boolean);
+
+  const ok = await ui.confirm(
+    zh ? "确认开始审查？" : "Start review?",
+    summaryLines.join("\n"),
+  );
+  if (!ok) {
+    ui.notify(zh ? "已取消" : "Cancelled", "info");
+    return undefined;
+  }
+
+  return {
+    ...seed,
+    strategy,
+    mode,
+    target,
+    ...(maxRounds !== undefined ? { maxRounds } : {}),
+    ...(until ? { until } : {}),
+    ...(panel ? { panel } : {}),
+    ...(reviewers !== undefined ? { reviewers } : {}),
+    ...(reviewerModels.length ? { reviewerModels } : {}),
+    ...(seed.model ? { model: seed.model } : {}),
+    ...(seed.thinking ? { thinking: seed.thinking } : {}),
+    ...(consensus ? { consensus } : {}),
+    ...(minAgree !== undefined ? { minAgree } : {}),
+    keepSession: seed.keepSession,
+    noStream: seed.noStream,
+    modelsOnly: false,
+  };
+}
+
+const INTERACTIVE_TOKEN_RE = /(?:^|\s)(?:interactive|--interactive|-i)(?=\s|$)/i;
+
+/** True when the invocation should open the interactive wizard. */
+export function shouldRunInteractiveWizard(rawArgs: string, parsed: RvParsed): boolean {
+  const trimmed = rawArgs.trim();
+  if (!trimmed) return true;
+  if (INTERACTIVE_TOKEN_RE.test(` ${trimmed} `) || /^(interactive|--interactive|-i)\b/i.test(trimmed)) {
+    return true;
+  }
+  // Power users with full flags are never interrupted unless they ask for interactive.
+  void parsed;
+  return false;
+}
+
+/** Remove interactive trigger tokens anywhere in the arg string. */
+export function stripInteractiveToken(rawArgs: string): string {
+  return rawArgs
+    .replace(/(?:^|\s)(?:interactive|--interactive|-i)(?=\s|$)/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/extensions/rv-locale.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import { detectRvLocale } from "./rv-locale.js";
 
 describe("detectRvLocale", () => {
@@ -8,10 +8,18 @@ describe("detectRvLocale", () => {
   });
 
   it("returns en for English-only samples", () => {
-    assert.equal(detectRvLocale(["Please review this diff", "Thanks"]), "en");
+    assert.equal(detectRvLocale(["Please review this diff", "Thanks"], { LANG: "en_US.UTF-8" }), "en");
   });
 
-  it("defaults to en when empty", () => {
-    assert.equal(detectRvLocale([]), "en");
+  it("defaults to system zh when samples empty", () => {
+    assert.equal(detectRvLocale([], { LANG: "zh_CN.UTF-8" }), "zh");
+    assert.equal(detectRvLocale([], { LANG: "en_US.UTF-8" }), "en");
+  });
+
+  it("prefers zh for mixed samples with any meaningful Chinese", () => {
+    assert.equal(
+      detectRvLocale(["Please review this diff", "帮我看下鉴权"]),
+      "zh",
+    );
   });
 });