@zephyrdeng/pi-review 0.7.1 → 0.8.1

package/extensions/review.ts

@@ -1,4 +1,5 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
 import {
   buildRvCompletions,
   type ModelInfo,
@@ -7,20 +8,31 @@ import { detectRvLocale } from "./rv-locale.js";
 import {
   buildRvOrchestrationPrompt,
   parseRvArgs,
-  RV_COMPLETIONS,
   validateRvParsed,
+  type RvStrategy,
 } from "./rv-prompts.js";
+import { resolveRvParsed } from "./rv-resolve.js";
+import {
+  runRvInteractiveWizard,
+  shouldRunInteractiveWizard,
+  stripInteractiveToken,
+} from "./rv-interactive.js";
+import { RvModelPickerComponent, type ModelPickerResult } from "./rv-model-picker.js";
 import { registerPanelReviewTool } from "./panel-tool.js";
 
 /**
  * Captured at `session_start` so the synchronous-ish `getArgumentCompletions`
  * callback (which receives only the argument prefix) can read the live model
- * registry without ctx. Stays undefined in non-TUI/print mode; completions then
- * gracefully degrade to the static `RV_COMPLETIONS` fallback.
+ * registry without ctx. Stays undefined in non-TUI/print mode; the pure
+ * completion builder then provides prefix-safe static suggestions.
  */
 let capturedModels: ModelInfo[] | undefined;
 let capturedPrimaryProvider: string | undefined;
-let capturedLocale: ReturnType<typeof detectRvLocale> = "en";
+let capturedLocale: ReturnType<typeof detectRvLocale> = detectRvLocale([]);
+/** Keep a registry handle so completions can refresh models lazily if session_start saw none yet. */
+let capturedModelRegistry: { getAvailable?: () => unknown[] } | undefined;
+/** Keep session manager so locale can re-detect on each completion as Chinese messages arrive. */
+let capturedSessionManager: { getEntries?: () => Array<{ type?: string; content?: unknown }> } | undefined;
 
 function sampleSessionText(
   sessionManager: { getEntries?: () => Array<{ type?: string; content?: unknown }> },
@@ -68,68 +80,200 @@ function toModelInfo(m: {
   };
 }
 
+function refreshCapturedModels(
+  registry?: { getAvailable?: () => unknown[] },
+  primaryProvider?: string,
+): ModelInfo[] {
+  if (registry) capturedModelRegistry = registry;
+  if (primaryProvider) capturedPrimaryProvider = primaryProvider;
+  try {
+    const available = (capturedModelRegistry?.getAvailable?.() ?? []) as Array<Parameters<typeof toModelInfo>[0]>;
+    if (available.length > 0) {
+      capturedModels = available.map((m) => toModelInfo(m));
+    }
+  } catch {
+    // keep previous capture
+  }
+  return capturedModels ?? [];
+}
+
 export default function piReviewExtension(pi: ExtensionAPI) {
   registerPanelReviewTool(pi);
   pi.on("session_start", (_event, ctx) => {
     try {
-      const available = ctx.modelRegistry?.getAvailable?.() ?? [];
-      capturedModels = available.map((m) => toModelInfo(m as unknown as Parameters<typeof toModelInfo>[0]));
+      // Model availability is session-scoped. Clear the previous snapshot before
+      // the new registry is sampled so an empty/cold catalog cannot leak stale IDs.
+      capturedModels = undefined;
+      capturedModelRegistry = ctx.modelRegistry;
       capturedPrimaryProvider = ctx.model?.provider;
+      capturedSessionManager = ctx.sessionManager;
       capturedLocale = detectRvLocale(sampleSessionText(ctx.sessionManager));
+      refreshCapturedModels(ctx.modelRegistry, ctx.model?.provider);
     } catch {
       capturedModels = undefined;
       capturedPrimaryProvider = undefined;
-      capturedLocale = "en";
+      capturedLocale = detectRvLocale([]);
     }
   });
 
-  function localeForHandler(ctx: { sessionManager?: Parameters<typeof sampleSessionText>[0] }): typeof capturedLocale {
+  function localeForHandler(ctx?: { sessionManager?: Parameters<typeof sampleSessionText>[0] }): typeof capturedLocale {
     try {
-      return detectRvLocale(sampleSessionText(ctx.sessionManager ?? { getEntries: () => [] }));
+      const manager = ctx?.sessionManager ?? capturedSessionManager ?? { getEntries: () => [] };
+      capturedLocale = detectRvLocale(sampleSessionText(manager));
+      return capturedLocale;
     } 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",
-    getArgumentCompletions: (prefix): ReturnType<typeof buildRvCompletions> => {
-      // Try dynamic completion first (models + thinking + scene templates).
-      if (capturedModels && capturedModels.length > 0) {
-        const dynamic = buildRvCompletions(prefix, {
-          models: capturedModels,
-          primaryProvider: capturedPrimaryProvider,
-          locale: capturedLocale,
-        });
-        if (dynamic && dynamic.length) return dynamic;
-      }
-      // Graceful fallback to static hint list when registry is unavailable.
-      const filtered = RV_COMPLETIONS.filter((item) => item.value.startsWith(prefix));
-      return filtered.length
-        ? filtered.map(({ value, hint }) => ({ value, label: value, description: hint }))
-        : null;
+  function argumentCompletions(
+    prefix: string,
+    strategy: RvStrategy = "panel",
+  ): ReturnType<typeof buildRvCompletions> {
+    // Always try a lazy refresh. session_start can race before providers finish loading.
+    const models = refreshCapturedModels();
+    // Re-detect locale every completion so Chinese sessions don't stay stuck on English labels.
+    const locale = localeForHandler();
+    return buildRvCompletions(prefix, {
+      models,
+      primaryProvider: capturedPrimaryProvider,
+      locale,
+      strategy,
+    });
+  }
+
+  async function handleRvCommand(
+    strategy: RvStrategy,
+    rawArgs: string,
+    ctx: {
+      ui: {
+        notify: (message: string, level?: "warning" | "info" | "error") => void;
+        select?: (title: string, options: string[]) => Promise<string | undefined>;
+        input?: (title: string, placeholder?: string) => Promise<string | undefined>;
+        confirm?: (title: string, message: string) => Promise<boolean>;
+        custom?: <T>(
+          factory: (
+            tui: TUI,
+            theme: Theme,
+            keybindings: KeybindingsManager,
+            done: (result: T) => void,
+          ) => Component & { dispose?(): void },
+          options?: { overlay?: boolean },
+        ) => Promise<T>;
+      };
+      sessionManager?: Parameters<typeof sampleSessionText>[0];
     },
-    handler: async (rawArgs, ctx) => {
-      const trimmed = rawArgs.trim();
-      if (!trimmed) {
-        ctx.ui.notify("/rv needs a target or `models`. Try: /rv @path or /rv models", "warning");
-        return;
-      }
+  ): Promise<void> {
+    if (strategy === "models") {
+      const parsed = parseRvArgs("", "models");
+      pi.sendUserMessage(buildRvOrchestrationPrompt(parsed, localeForHandler(ctx)));
+      return;
+    }
 
-      const parsed = parseRvArgs(trimmed);
-      const validation = validateRvParsed(parsed);
-      if (!validation.ok) {
-        ctx.ui.notify(validation.message, "warning");
-        return;
-      }
+    const interactiveRequested = shouldRunInteractiveWizard(rawArgs, parseRvArgs(stripInteractiveToken(rawArgs), strategy));
+    const trimmed = stripInteractiveToken(rawArgs).trim();
+    let parsed = parseRvArgs(trimmed, strategy);
+
+    // Interactive wizard: empty command or explicit `interactive` / `--interactive` / `-i`.
+    // Uses Pi select/input/confirm dialogs — no tab completion required for model assignment.
+    if (interactiveRequested && ctx.ui.select && ctx.ui.input && ctx.ui.confirm) {
+      const models = refreshCapturedModels();
+      const locale = localeForHandler(ctx);
+      const wizardResult = await runRvInteractiveWizard(
+        {
+          select: (title, options) => ctx.ui.select!(title, options),
+          input: (title, placeholder) => ctx.ui.input!(title, placeholder),
+          confirm: (title, message) => ctx.ui.confirm!(title, message),
+          notify: (message, type) => ctx.ui.notify(message, type),
+          // Inline searchable picker, available only in TUI mode (ctx.ui.custom).
+          // The factory builds the component; the host grants focus and forwards
+          // keystrokes. print/RPC modes have no `custom` → wizard falls back to
+          // the select-based flow.
+          customModelPicker: ctx.ui.custom
+            ? (pickerInput) =>
+                ctx.ui.custom!<ModelPickerResult>((tui, theme, keybindings, done) =>
+                  RvModelPickerComponent.create(
+                    tui,
+                    theme as unknown as Theme,
+                    keybindings,
+                    done,
+                    pickerInput,
+                  ),
+                )
+            : undefined,
+        },
+        {
+          strategy: strategy === "loop" ? "loop" : "panel",
+          seed: parsed,
+          models,
+          locale,
+          primaryProvider: capturedPrimaryProvider,
+        },
+      );
+      if (!wizardResult) return;
+      parsed = wizardResult;
+    } else if (!trimmed) {
+      // No dialog API (print/RPC) and empty args → tell user how to run interactive.
+      ctx.ui.notify(
+        strategy === "loop"
+          ? "/rv-loop interactive  · or /rv-loop --reviewers 3 --reviewer-model r1=... @src"
+          : "/rv interactive  · or /rv --panel code-experts @src",
+        "warning",
+      );
+      return;
+    }
+
+    const validation = validateRvParsed(parsed);
+    if (!validation.ok) {
+      ctx.ui.notify(validation.message, "warning");
+      return;
+    }
+
+    if (!parsed.modelsOnly && !parsed.target && !parsed.continueHandle) {
+      ctx.ui.notify("/rv needs a natural-language target, --continue <handle>, interactive, or /rv-models.", "warning");
+      return;
+    }
 
-      if (!parsed.modelsOnly && !parsed.target && !parsed.continueHandle) {
-        ctx.ui.notify("/rv needs a target, --continue <handle>, or `models`.", "warning");
+    const resolved = resolveRvParsed(parsed, refreshCapturedModels(), capturedPrimaryProvider);
+    if (resolved.ambiguousModels?.length) {
+      // Prefer interactive disambiguation when dialogs exist.
+      if (ctx.ui.select) {
+        const pick = await ctx.ui.select(
+          `Ambiguous model "${parsed.model}"`,
+          resolved.ambiguousModels,
+        );
+        if (!pick) return;
+        resolved.parsed = { ...resolved.parsed, model: pick };
+        resolved.notes.push(`model ${parsed.model} → ${pick} (interactive pick)`);
+      } else {
+        ctx.ui.notify(
+          `Model "${parsed.model}" is ambiguous. Candidates: ${resolved.ambiguousModels.join(", ")}. Re-run with an exact provider/model.`,
+          "warning",
+        );
         return;
       }
+    }
 
-      pi.sendUserMessage(buildRvOrchestrationPrompt(parsed, localeForHandler(ctx)));
-    },
+    pi.sendUserMessage(buildRvOrchestrationPrompt(resolved.parsed, localeForHandler(ctx), resolved.notes));
+  }
+
+  pi.registerCommand("rv", {
+    description:
+      "Panel review. /rv interactive for dialog wizard; or /rv [flags] <natural-language target>",
+    getArgumentCompletions: (prefix) => argumentCompletions(prefix, "panel"),
+    handler: async (rawArgs, ctx) => handleRvCommand("panel", rawArgs, ctx),
+  });
+
+  pi.registerCommand("rv-loop", {
+    description:
+      "Loop closeout. /rv-loop interactive for dialog wizard (pick reviewers & models with arrows); or pass flags",
+    getArgumentCompletions: (prefix) => argumentCompletions(prefix, "loop"),
+    handler: async (rawArgs, ctx) => handleRvCommand("loop", rawArgs, ctx),
+  });
+
+  pi.registerCommand("rv-models", {
+    description: "List pi-review models. Usage: /rv-models",
+    getArgumentCompletions: (prefix) => argumentCompletions(prefix, "models"),
+    handler: async (_rawArgs, ctx) => handleRvCommand("models", "", ctx),
   });
 }

package/extensions/rv-completions.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   buildRvCompletions,
   extractSignals,
@@ -11,6 +11,7 @@ import {
 } from "./rv-completions.js";
 import { rvUi } from "./rv-locale.js";
 import { DEFAULT_REVIEW_MODEL_PRIORITIES } from "./rv-model-priorities.js";
+import { parseRvArgs, validateRvParsed } from "./rv-prompts.js";
 
 function model(partial: Partial<ModelInfo> & Pick<ModelInfo, "provider" | "id">): ModelInfo {
   return {
@@ -24,7 +25,13 @@ function model(partial: Partial<ModelInfo> & Pick<ModelInfo, "provider" | "id">)
 }
 
 const MODELS: ModelInfo[] = [
-  model({ provider: "anthropic", id: "claude-opus-4-6", reasoning: true, contextWindow: 200_000, thinkingLevels: ["off", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "openai-codex", id: "gpt-5.6-sol", reasoning: true, contextWindow: 400_000, thinkingLevels: ["off", "minimal", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "openai-codex", id: "gpt-5.6-terra", reasoning: true, contextWindow: 400_000, thinkingLevels: ["off", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "openai-codex", id: "gpt-5.6-luna", reasoning: true, contextWindow: 400_000, thinkingLevels: ["high", "xhigh"] }),
+  model({ provider: "anthropic", id: "claude-opus-4-8", reasoning: true, contextWindow: 200_000, thinkingLevels: ["off", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "anthropic", id: "claude-sonnet-4-5", reasoning: true, contextWindow: 200_000, thinkingLevels: ["off", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "anthropic", id: "claude-fable-5", reasoning: true, contextWindow: 200_000, thinkingLevels: ["high", "xhigh"] }),
+  model({ provider: "deepseek", id: "deepseek-v4-flash", reasoning: true, contextWindow: 200_000, thinkingLevels: ["high", "xhigh"] }),
   model({ provider: "openai", id: "gpt-5.5", reasoning: true, contextWindow: 400_000, thinkingLevels: ["off", "minimal", "low", "medium", "high", "xhigh"] }),
   model({ provider: "zenmux", id: "gemini-3-flash", reasoning: false, contextWindow: 1_000_000, thinkingLevels: [] }),
 ];
@@ -80,16 +87,16 @@ describe("extractSignals", () => {
 });
 
 describe("rankModelsForReview", () => {
-  it("puts preset code models first when registered", () => {
+  it("puts fast-review models first for code presets", () => {
     const sig = extractSignals(["@src/a.ts"], {});
     const ranked = rankModelsForReview(MODELS, sig, DEFAULT_REVIEW_MODEL_PRIORITIES);
-    assert.equal(ranked[0].id, "gpt-5.5");
+    assert.equal(ranked[0].id, "claude-sonnet-4-5");
   });
 
-  it("puts preset plan models first for plan mode", () => {
+  it("puts complex/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");
+    assert.equal(ranked[0].id, "gpt-5.6-sol");
   });
 });
 
@@ -125,12 +132,12 @@ describe("buildRvCompletions", () => {
   });
 
   it("completes thinking suffix after provider/id: for a reasoning model", () => {
-    const items = buildRvCompletions("--model openai/gpt-5.5:", deps);
+    const items = buildRvCompletions("--model openai-codex/gpt-5.6-sol:", deps);
     assert.ok(items);
     const labels = items!.map((i) => i.label);
     assert.ok(labels.includes("high"));
     assert.ok(labels.includes("xhigh"));
-    assert.ok(items!.every((i) => i.value.startsWith("--model openai/gpt-5.5:")));
+    assert.ok(items!.every((i) => i.value.startsWith("--model openai-codex/gpt-5.6-sol:")));
   });
 
   it("does not offer thinking suffix for a non-reasoning model", () => {
@@ -167,14 +174,151 @@ describe("buildRvCompletions", () => {
     assert.equal(buildRvCompletions("--continue abc", deps), null);
   });
 
-  it("offers scene templates + models keyword at empty top level", () => {
+  it("empty top-level stays quiet: flags/hints, no preset wall", () => {
     const items = buildRvCompletions("", deps);
     const ui = rvUi("en");
     assert.ok(items);
-    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(" @"));
+    assert.ok(items!.some((i) => i.value === "-i" || i.label.includes("interactive")));
+    assert.ok(items!.some((i) => i.label === ui.presetHint));
+    assert.ok(!items!.some((i) => i.label === ui.codePreset));
+  });
+
+  it("-i / --interactive complete to the wizard trigger, not the flag soup", () => {
+    for (const prefix of ["-i", "--interactive", "-"]) {
+      const items = buildRvCompletions(prefix, { ...deps, strategy: "loop" });
+      assert.ok(items?.some((i) => i.value === "-i" || i.value === "--interactive"), prefix);
+      assert.ok(!items?.some((i) => i.label === "--max-rounds 1" || i.value.startsWith("--max-rounds 1")), prefix);
+    }
+  });
+
+  it("presets appear only when the user asks for them", () => {
+    const ui = rvUi("en");
+    const quiet = buildRvCompletions("gpt", deps);
+    assert.ok(!quiet?.some((i) => i.label === ui.codePreset));
+    const asked = buildRvCompletions("preset", deps);
+    assert.ok(asked?.some((i) => i.label === ui.codePreset), `got ${asked?.map((i) => i.label).join(",")}`);
+    const zh = buildRvCompletions("预设", { ...deps, locale: "zh" });
+    assert.ok(zh?.some((i) => i.label === rvUi("zh").codePreset), `got ${zh?.map((i) => i.label).join(",")}`);
+  });
+
+  it("/rv-loop empty top-level stays quiet; loop presets need explicit request", () => {
+    const empty = buildRvCompletions("", { ...deps, strategy: "loop" });
+    assert.ok(empty);
+    assert.ok(!empty!.some((i) => /Loop closeout|关单/.test(i.label)));
+    assert.ok(!empty!.some((i) => i.value.includes("--keep-session")));
+    const asked = buildRvCompletions("preset", { ...deps, strategy: "loop" });
+    assert.ok(asked?.some((i) => /Loop closeout/.test(i.label)));
+  });
+
+  it("Chinese locale labels are used when locale=zh", () => {
+    const items = buildRvCompletions("预设", { ...deps, locale: "zh" });
+    const ui = rvUi("zh");
+    assert.ok(items?.some((i) => i.label === ui.codePreset));
+    assert.ok(items?.some((i) => i.description?.includes("--model")));
+  });
+
+  it("/rv-loop bare model typing surfaces catalog matches as --model values", () => {
+    const items = buildRvCompletions("gpt-5.6-sol", { ...deps, strategy: "loop" });
+    assert.ok(items);
+    assert.ok(items!.some((i) => i.value.includes("--model") && i.label.includes("gpt-5.6-sol")));
+  });
+
+  it("/rv-loop accepts full provider/model and offers thinking suffixes", () => {
+    const items = buildRvCompletions("openai-codex/gpt-5.6-sol", { ...deps, strategy: "loop" });
+    assert.ok(items);
+    assert.ok(items!.some((i) => i.value === "--model openai-codex/gpt-5.6-sol"));
+    assert.ok(items!.some((i) => i.value.startsWith("--model openai-codex/gpt-5.6-sol:")));
+  });
+
+  it("/rv-loop provider fragment still surfaces models", () => {
+    const items = buildRvCompletions("openai-codex", { ...deps, strategy: "loop" });
+    assert.ok(items);
+    assert.ok(items!.some((i) => i.label.includes("openai-codex/") || i.value.includes("openai-codex/")));
+  });
+
+  it("/rv-models does not offer panel scene templates or targets", () => {
+    const items = buildRvCompletions("", { ...deps, strategy: "models" });
+    assert.ok(items);
+    assert.ok(items!.every((i) => /model/i.test(i.label)));
+    assert.ok(!items!.some((i) => i.value.includes("@src") || i.value.includes("--model")));
+  });
+
+  it("/rv-models completion never clears an already-entered prefix", () => {
+    for (const prefix of ["unexpected target ", "unexpected target mod"]) {
+      const items = buildRvCompletions(prefix, { models: [], strategy: "models" });
+      assert.ok(items, prefix);
+      assert.ok(items!.every((item) => item.value.startsWith(prefix)), prefix);
+    }
+  });
+
+  it("multi-word semantic completion replaces its typed phrase suffix without duplicating it", () => {
+    for (const prefix of ["@src code r", "@src code rev"]) {
+      const items = buildRvCompletions(prefix, { ...deps, strategy: "panel", locale: "en" });
+      const codeReview = items?.find((item) => item.label === "code review");
+      assert.ok(codeReview, prefix);
+      assert.equal(codeReview!.value, "@src code review");
+      assert.doesNotMatch(codeReview!.value, /code code review/);
+    }
+  });
+
+  it("/rv-loop flag completion includes --max-rounds and excludes --keep-session", () => {
+    const maxRounds = buildRvCompletions("--max", { ...deps, strategy: "loop" });
+    assert.ok(maxRounds?.some((i) => i.label === "--max-rounds"));
+    const keep = buildRvCompletions("--keep", { ...deps, strategy: "loop" });
+    assert.ok(!keep?.some((i) => i.label === "--keep-session"));
+  });
+
+  it("/rv-loop completes --reviewers values and panel strategy flags", () => {
+    const flags = buildRvCompletions("--rev", { ...deps, strategy: "loop" });
+    assert.ok(flags?.some((i) => i.label === "--reviewers"), `got ${flags?.map((i) => i.label)}`);
+    const values = buildRvCompletions("--reviewers ", { ...deps, strategy: "loop" });
+    assert.ok(values?.some((i) => i.label === "3"));
+    const consensus = buildRvCompletions("--consensus ", { ...deps, strategy: "loop" });
+    assert.ok(consensus?.some((i) => i.label === "quorum"));
+    const panel = buildRvCompletions("--panel ", { ...deps, strategy: "loop" });
+    assert.ok(panel?.some((i) => i.label === "code-experts"));
+  });
+
+  it("offers an explicit target boundary after completed flags so target text can be entered last", () => {
+    const prefix = "--mode plan --panel code-experts ";
+    const items = buildRvCompletions(prefix, { ...deps, strategy: "panel", locale: "en" });
+    const boundary = items?.find((item) => item.label === "Start review target");
+    assert.ok(boundary, `got ${items?.map((item) => item.label).join(", ")}`);
+    assert.equal(boundary!.value, "--mode plan --panel code-experts -- ");
+
+    const parsed = parseRvArgs(`${boundary!.value}code review the auth changes under @src`);
+    assert.equal(parsed.mode, "plan");
+    assert.equal(parsed.panel, "code-experts");
+    assert.equal(parsed.target, "code review the auth changes under @src");
+    assert.deepEqual(validateRvParsed(parsed), { ok: true });
+  });
+
+  it("hides --panel after --reviewers and vice versa", () => {
+    const afterReviewers = buildRvCompletions("--reviewers 3 --p", { ...deps, strategy: "loop" });
+    assert.ok(!afterReviewers?.some((i) => i.label === "--panel"));
+    const afterPanel = buildRvCompletions("--panel code-experts --r", { ...deps, strategy: "loop" });
+    assert.ok(!afterPanel?.some((i) => i.label === "--reviewers"));
+  });
+
+  it("--reviewer-model offers cascading id then model menus based on --reviewers count", () => {
+    const ids = buildRvCompletions("--reviewers 3 --reviewer-model ", { ...deps, strategy: "loop" });
+    assert.deepEqual(ids?.map((i) => i.label).sort(), ["r1=", "r2=", "r3="].sort());
+
+    const models = buildRvCompletions("--reviewers 3 --reviewer-model r1=", { ...deps, strategy: "loop" });
+    assert.ok(models?.some((i) => i.label.startsWith("r1=") && i.label.includes("/")), `got ${models?.map((i) => i.label)}`);
+
+    const afterOne = buildRvCompletions(
+      "--reviewers 2 --reviewer-model r1=openai-codex/gpt-5.6-sol --reviewer-model ",
+      { ...deps, strategy: "loop" },
+    );
+    assert.ok(afterOne?.some((i) => i.label === "r2="));
+    assert.ok(!afterOne?.some((i) => i.label === "r1="));
+  });
+
+  it("--reviewer-model with --panel code-experts uses role ids", () => {
+    const ids = buildRvCompletions("--panel code-experts --reviewer-model ", { ...deps, strategy: "panel" });
+    assert.ok(ids?.some((i) => i.label === "security="));
+    assert.ok(ids?.some((i) => i.label === "correctness="));
   });
 
   it("does not duplicate list-models completion at top level", () => {
@@ -218,11 +362,15 @@ describe("buildRvCompletions", () => {
   });
 
   it("omits preset scene templates when registry has no preset id match", () => {
-    const nonReasoning = [{ ...MODELS[2], thinkingLevels: [] }] as ModelInfo[];
-    const items = buildRvCompletions("", { models: nonReasoning, priorities: DEFAULT_REVIEW_MODEL_PRIORITIES });
-    assert.ok(items);
-    assert.ok(!items!.some((i) => i.label === rvUi("en").codePreset));
-    assert.ok(items!.some((i) => i.label === rvUi("en").listModels));
+    // Only a non-matching flash model: none of the code/plan/frontend preset needles hit.
+    const nonMatching = [
+      model({ provider: "zenmux", id: "gemini-3-flash", reasoning: false, contextWindow: 1_000_000, thinkingLevels: [] }),
+    ];
+    const empty = buildRvCompletions("", { models: nonMatching, priorities: DEFAULT_REVIEW_MODEL_PRIORITIES });
+    assert.ok(empty);
+    assert.ok(!empty!.some((i) => i.label === rvUi("en").codePreset));
+    const asked = buildRvCompletions("preset", { models: nonMatching, priorities: DEFAULT_REVIEW_MODEL_PRIORITIES });
+    assert.ok(!asked?.some((i) => i.label === rvUi("en").codePreset));
   });
 
   it("falls back gracefully when models are unavailable (static flags still work)", () => {
@@ -230,4 +378,15 @@ describe("buildRvCompletions", () => {
     assert.ok(items);
     assert.ok(items!.some((i) => i.label === "code" || i.label === "plan" || i.label === "challenge"));
   });
+
+  it("preserves entered targets when the model catalog is unavailable", () => {
+    const valuePosition = buildRvCompletions("@src --model ", { models: [], strategy: "panel" });
+    assert.ok(valuePosition);
+    assert.ok(valuePosition!.every((item) => item.value.startsWith("@src --model ")));
+
+    const bareModel = buildRvCompletions("@src gpt-5.6", { models: [], strategy: "panel" });
+    assert.ok(bareModel);
+    assert.ok(bareModel!.some((item) => item.value === "@src --model gpt-5.6"));
+    assert.ok(bareModel!.every((item) => item.value.startsWith("@src ")));
+  });
 });