@zephyrdeng/pi-review 0.7.0 → 0.8.0

package/extensions/rv-resolve.test.ts

@@ -0,0 +1,189 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import type { ModelInfo } from "./rv-completions.js";
+import {
+  canonicalizeThinking,
+  extractModelThinkingFromText,
+  normalizeModelKey,
+  resolveModelFromCatalog,
+  resolveRvParsed,
+  resolveThinking,
+} from "./rv-resolve.js";
+import type { RvParsed } from "./rv-prompts.js";
+
+const models: ModelInfo[] = [
+  {
+    provider: "openai-codex",
+    id: "gpt-5.5",
+    label: "openai-codex/gpt-5.5",
+    name: "gpt-5.5",
+    reasoning: true,
+    contextWindow: 200000,
+    thinkingLevels: ["low", "medium", "high", "xhigh"],
+  },
+  {
+    provider: "openai",
+    id: "gpt-5.5",
+    label: "openai/gpt-5.5",
+    name: "gpt-5.5",
+    reasoning: true,
+    contextWindow: 200000,
+    thinkingLevels: ["medium", "high"],
+  },
+  {
+    provider: "wafer.ai",
+    id: "Kimi-K2.6",
+    label: "wafer.ai/Kimi-K2.6",
+    name: "Kimi",
+    reasoning: true,
+    contextWindow: 128000,
+    thinkingLevels: ["low", "high"],
+  },
+  {
+    provider: "anthropic",
+    id: "claude-opus-4-8",
+    label: "anthropic/claude-opus-4-8",
+    name: "opus",
+    reasoning: true,
+    contextWindow: 200000,
+    thinkingLevels: ["high", "xhigh"],
+  },
+  {
+    provider: "px:anthropic",
+    id: "claude-opus-4-8",
+    label: "px:anthropic/claude-opus-4-8",
+    name: "opus-px",
+    reasoning: true,
+    contextWindow: 200000,
+    thinkingLevels: ["high", "xhigh"],
+  },
+  {
+    provider: "px:anthropic",
+    id: "claude-sonnet-4-5",
+    label: "px:anthropic/claude-sonnet-4-5",
+    name: "sonnet-px",
+    reasoning: true,
+    contextWindow: 200000,
+    thinkingLevels: ["medium", "high"],
+  },
+  {
+    provider: "px:anthropic",
+    id: "claude-haiku-4-5",
+    label: "px:anthropic/claude-haiku-4-5",
+    name: "haiku-px",
+    reasoning: true,
+    contextWindow: 200000,
+    thinkingLevels: ["low", "medium"],
+  },
+];
+
+function baseParsed(over: Partial<RvParsed> = {}): RvParsed {
+  return {
+    strategy: "panel",
+    mode: "code",
+    keepSession: false,
+    noStream: false,
+    modelsOnly: false,
+    target: "@src",
+    ...over,
+  };
+}
+
+test("normalizeModelKey collapses separators", () => {
+  assert.equal(normalizeModelKey("GPT-5.5"), "gpt55");
+  assert.equal(normalizeModelKey("gpt_5_5"), "gpt55");
+  assert.equal(normalizeModelKey("openai-codex/gpt-5.5"), "openaicodex/gpt55");
+});
+
+test("thinking aliases and model-supported fallback", () => {
+  assert.equal(canonicalizeThinking("最高"), "xhigh");
+  assert.equal(canonicalizeThinking("max"), "xhigh");
+  assert.deepEqual(resolveThinking("xhigh", ["low", "medium", "high"]), {
+    status: "fallback",
+    level: "high",
+    from: "xhigh",
+    reason: "xhigh unsupported; using high",
+  });
+  assert.equal(resolveThinking("high", ["low", "medium", "high"]).status, "exact");
+});
+
+test("model catalog resolves short ids and prefers primary provider", () => {
+  const unique = resolveModelFromCatalog("gpt-5.5", models, "openai-codex");
+  assert.equal(unique.status, "unique");
+  if (unique.status === "unique") assert.equal(unique.model.label, "openai-codex/gpt-5.5");
+
+  const exact = resolveModelFromCatalog("openai/gpt-5.5", models);
+  assert.equal(exact.status, "exact");
+
+  const kimi = resolveModelFromCatalog("kimi", models);
+  assert.equal(kimi.status, "unique");
+  if (kimi.status === "unique") assert.equal(kimi.model.label, "wafer.ai/Kimi-K2.6");
+});
+
+test("extractModelThinkingFromText never rewrites natural-language targets", () => {
+  const original = "review high memory usage under @src";
+  const extracted = extractModelThinkingFromText(original, models, "openai-codex");
+  assert.equal(extracted.target, original);
+  assert.equal(extracted.model, undefined);
+  assert.equal(extracted.thinking, undefined);
+});
+
+test("resolveRvParsed normalizes flags and inline model:thinking", () => {
+  const resolved = resolveRvParsed(
+    baseParsed({ model: "gpt-5.5", thinking: "最高" }),
+    models,
+    "openai-codex",
+  );
+  assert.equal(resolved.parsed.model, "openai-codex/gpt-5.5");
+  assert.equal(resolved.parsed.thinking, "xhigh");
+  assert.ok(resolved.notes.some((note) => /model gpt-5\.5/.test(note)));
+
+  const inline = resolveRvParsed(baseParsed({ model: "openai/gpt-5.5:xhigh" }), models);
+  assert.equal(inline.parsed.model, "openai/gpt-5.5");
+  assert.equal(inline.parsed.thinking, "high"); // model only supports up to high
+  assert.ok(inline.notes.some((note) => /thinking/.test(note)));
+});
+
+test("resolveRvParsed keeps natural-language targets verbatim", () => {
+  const target = "review high memory usage under @src";
+  const resolved = resolveRvParsed(baseParsed({ target }), models);
+  assert.equal(resolved.parsed.target, target);
+  assert.equal(resolved.parsed.model, undefined);
+  assert.equal(resolved.parsed.thinking, undefined);
+});
+
+test("resolveRvParsed resolves short names inside --reviewer-model mappings", () => {
+  const resolved = resolveRvParsed(
+    baseParsed({
+      reviewers: 2,
+      reviewerModels: ["r1=gpt-5.5:最高", "r2=kimi"],
+    }),
+    models,
+    "openai-codex",
+  );
+  assert.deepEqual(resolved.parsed.reviewerModels, [
+    "r1=openai-codex/gpt-5.5:xhigh",
+    "r2=wafer.ai/Kimi-K2.6",
+  ]);
+  assert.ok(resolved.notes.some((note) => /reviewer-model r1/.test(note)));
+});
+
+test("px:anthropic exact catalog ids keep provider colons", () => {
+  for (const label of [
+    "px:anthropic/claude-opus-4-8",
+    "px:anthropic/claude-sonnet-4-5",
+    "px:anthropic/claude-haiku-4-5",
+  ]) {
+    const resolved = resolveModelFromCatalog(label, models);
+    assert.equal(resolved.status, "exact", label);
+    if (resolved.status === "exact") assert.equal(resolved.model.label, label);
+  }
+
+  const withThinking = resolveRvParsed(
+    baseParsed({ model: "px:anthropic/claude-opus-4-8:xhigh" }),
+    models,
+  );
+  assert.equal(withThinking.parsed.model, "px:anthropic/claude-opus-4-8");
+  assert.equal(withThinking.parsed.thinking, "xhigh");
+  assert.ok(withThinking.notes.some((note) => /thinking suffix/.test(note)));
+});

package/extensions/rv-resolve.ts

@@ -0,0 +1,313 @@
+/**
+ * Human-friendly model / thinking resolution against a live Pi catalog.
+ * Pure and testable: completion and /rv execution share the same rules.
+ */
+
+import type { ModelInfo } from "./rv-completions.js";
+import { THINKING_LEVELS } from "./rv-completions.js";
+import type { RvParsed } from "./rv-prompts.js";
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+const THINKING_ALIASES: Record<string, ThinkingLevel> = {
+  off: "off",
+  none: "off",
+  "0": "off",
+  false: "off",
+  关闭: "off",
+  无: "off",
+  快: "off",
+  fast: "off",
+  minimal: "minimal",
+  min: "minimal",
+  最低: "minimal",
+  low: "low",
+  低: "low",
+  medium: "medium",
+  mid: "medium",
+  med: "medium",
+  中: "medium",
+  中等: "medium",
+  high: "high",
+  高: "high",
+  高思考: "high",
+  xhigh: "xhigh",
+  max: "xhigh",
+  maximum: "xhigh",
+  ultra: "xhigh",
+  最高: "xhigh",
+  最强: "xhigh",
+  满思考: "xhigh",
+};
+
+/** Strip only a trailing `:thinking` suffix; preserve provider colons such as `px:anthropic/...`. */
+export function stripTrailingThinkingSuffix(value: string): { model: string; thinking?: string } {
+  const idx = value.lastIndexOf(":");
+  if (idx <= 0) return { model: value };
+  const after = value.slice(idx + 1).trim();
+  // Thinking suffixes are bare levels, never path-like fragments containing `/`.
+  if (!after || after.includes("/") || !canonicalizeThinking(after)) return { model: value };
+  return { model: value.slice(0, idx), thinking: after };
+}
+
+/** Collapse separators so gpt5.5 / gpt_5_5 / GPT-5.5 share one key. Keep `/` and provider `:`. */
+export function normalizeModelKey(value: string): string {
+  const { model } = stripTrailingThinkingSuffix(value);
+  return model
+    .toLowerCase()
+    .replace(/[^a-z0-9:/]+/g, "")
+    .replace(/\/+/g, "/");
+}
+
+export function canonicalizeThinking(raw: string | undefined): ThinkingLevel | undefined {
+  if (!raw) return undefined;
+  const key = raw.trim().toLowerCase();
+  if ((THINKING_LEVELS as readonly string[]).includes(key)) return key as ThinkingLevel;
+  return THINKING_ALIASES[key] ?? THINKING_ALIASES[raw.trim()];
+}
+
+export type ThinkingResolve =
+  | { status: "exact"; level: ThinkingLevel }
+  | { status: "alias"; level: ThinkingLevel; from: string }
+  | { status: "fallback"; level: ThinkingLevel; from: string; reason: string }
+  | { status: "unsupported"; from: string; supported: string[] }
+  | { status: "none" };
+
+/** Map a user thinking token onto levels the model actually supports. */
+export function resolveThinking(
+  raw: string | undefined,
+  supported: string[] = [...THINKING_LEVELS],
+): ThinkingResolve {
+  if (!raw?.trim()) return { status: "none" };
+  const canonical = canonicalizeThinking(raw);
+  if (!canonical) return { status: "none" };
+  const levels = supported.length ? supported : [...THINKING_LEVELS];
+  if (levels.includes(canonical)) {
+    const rawIsCanonical = (THINKING_LEVELS as readonly string[]).includes(raw.trim().toLowerCase());
+    return rawIsCanonical
+      ? { status: "exact", level: canonical }
+      : { status: "alias", level: canonical, from: raw };
+  }
+  const order = [...THINKING_LEVELS];
+  const start = order.indexOf(canonical);
+  for (let i = start; i >= 0; i--) {
+    const level = order[i]!;
+    if (levels.includes(level)) {
+      return { status: "fallback", level, from: raw, reason: `${canonical} unsupported; using ${level}` };
+    }
+  }
+  for (const level of order) {
+    if (levels.includes(level)) {
+      return { status: "fallback", level, from: raw, reason: `${canonical} unsupported; using ${level}` };
+    }
+  }
+  return { status: "unsupported", from: raw, supported: levels };
+}
+
+export type ModelResolve =
+  | { status: "exact"; model: ModelInfo; query: string }
+  | { status: "unique"; model: ModelInfo; query: string; reason: string }
+  | { status: "ambiguous"; query: string; candidates: ModelInfo[] }
+  | { status: "none"; query: string };
+
+function splitProviderModel(query: string): { provider?: string; id: string } {
+  const cleaned = query.replace(/:.*$/, "").trim();
+  const slash = cleaned.indexOf("/");
+  if (slash === -1) return { id: cleaned };
+  return { provider: cleaned.slice(0, slash), id: cleaned.slice(slash + 1) };
+}
+
+function scoreModel(model: ModelInfo, query: string, primaryProvider?: string): number {
+  const q = normalizeModelKey(stripTrailingThinkingSuffix(query).model);
+  if (!q) return -1;
+  const label = normalizeModelKey(model.label);
+  const id = normalizeModelKey(model.id);
+  const provider = normalizeModelKey(model.provider);
+  const { provider: qProvider, id: qId } = (() => {
+    const slash = q.indexOf("/");
+    if (slash === -1) return { id: q };
+    return { provider: q.slice(0, slash), id: q.slice(slash + 1) };
+  })();
+
+  let score = 0;
+  if (label === q) score = 1000;
+  else if (id === q || id === qId) score = 900;
+  else if (label.endsWith(`/${qId}`) || id.endsWith(qId)) score = 800;
+  else if (id.includes(qId) || label.includes(q) || id.includes(q)) score = 600;
+  else return -1;
+
+  if (qProvider && provider === qProvider) score += 50;
+  if (primaryProvider && model.provider === primaryProvider) score += 20;
+  // Prefer longer/newer-looking ids when scores tie later.
+  score += Math.min(model.id.length, 40) / 100;
+  return score;
+}
+
+/** Resolve a user model token to catalog entries without inventing ids. */
+export function resolveModelFromCatalog(
+  query: string | undefined,
+  models: ModelInfo[],
+  primaryProvider?: string,
+): ModelResolve {
+  if (!query?.trim()) return { status: "none", query: "" };
+  const raw = query.trim();
+  // Only strip a trailing thinking suffix; keep provider colons (px:anthropic/...).
+  const modelQuery = stripTrailingThinkingSuffix(raw).model;
+
+  const exactLabel = models.find((m) => m.label === modelQuery || m.label === raw);
+  if (exactLabel) return { status: "exact", model: exactLabel, query: modelQuery };
+
+  const exactIds = models.filter((m) => m.id === modelQuery || m.id === raw);
+  if (exactIds.length === 1) return { status: "exact", model: exactIds[0]!, query: modelQuery };
+  if (exactIds.length > 1) {
+    const preferred =
+      (primaryProvider && exactIds.find((m) => m.provider === primaryProvider)) || exactIds[0]!;
+    return {
+      status: "unique",
+      model: preferred,
+      query: modelQuery,
+      reason: `matched catalog id ${preferred.label}`,
+    };
+  }
+
+  const ranked = models
+    .map((model) => ({ model, score: scoreModel(model, modelQuery, primaryProvider) }))
+    .filter((row) => row.score >= 0)
+    .sort((a, b) => b.score - a.score || b.model.id.localeCompare(a.model.id, undefined, { numeric: true }));
+
+  if (ranked.length === 0) return { status: "none", query: modelQuery };
+  const best = ranked[0]!;
+  const top = ranked.filter((row) => Math.abs(row.score - best.score) < 1);
+  // Treat as unique when one clear winner, or multiple share the same id across providers with a primary-provider preference.
+  if (top.length === 1 || (best.score >= 800 && top.every((row) => row.model.id === best.model.id))) {
+    const preferred =
+      primaryProvider && top.some((row) => row.model.provider === primaryProvider)
+        ? top.find((row) => row.model.provider === primaryProvider)!.model
+        : best.model;
+    return {
+      status: "unique",
+      model: preferred,
+      query: modelQuery,
+      reason: `matched catalog id ${preferred.label}`,
+    };
+  }
+  // Collapse same-score different families into ambiguous list (cap 5).
+  const candidates = ranked.slice(0, 5).map((row) => row.model);
+  return { status: "ambiguous", query: modelQuery, candidates };
+}
+
+/**
+ * Natural-language targets must stay verbatim. Model/thinking come only from
+ * explicit flags or an unambiguous `--model provider/model:thinking` suffix.
+ * This helper is retained for tests/docs as a no-rewrite identity.
+ */
+export function extractModelThinkingFromText(
+  text: string,
+  _models: ModelInfo[] = [],
+  _primaryProvider?: string,
+): { model?: string; thinking?: string; target: string; notes: string[] } {
+  return { target: text, notes: [] };
+}
+
+export type RvResolution = {
+  parsed: RvParsed;
+  notes: string[];
+  ambiguousModels?: string[];
+};
+
+/** Apply catalog-aware normalization to a parsed /rv invocation. */
+export function resolveRvParsed(
+  parsed: RvParsed,
+  models: ModelInfo[] = [],
+  primaryProvider?: string,
+): RvResolution {
+  const notes: string[] = [];
+  let next: RvParsed = { ...parsed };
+  let ambiguousModels: string[] | undefined;
+
+  // Inline --model provider/model:thinking only when the suffix is a real thinking level.
+  // Providers such as `px:anthropic/...` must keep their colon.
+  if (next.model) {
+    const split = stripTrailingThinkingSuffix(next.model);
+    if (split.thinking && split.model !== next.model) {
+      next = { ...next, model: split.model, thinking: next.thinking ?? split.thinking };
+      notes.push(`split --model thinking suffix :${split.thinking}`);
+    }
+  }
+
+  // Never rewrite natural-language targets by scavenging bare thinking/model words.
+
+  if (next.model && models.length > 0) {
+    const resolved = resolveModelFromCatalog(next.model, models, primaryProvider);
+    if (resolved.status === "exact" || resolved.status === "unique") {
+      if (resolved.model.label !== next.model) {
+        notes.push(`model ${next.model} → ${resolved.model.label}`);
+      }
+      next = { ...next, model: resolved.model.label };
+      if (next.thinking) {
+        const thinking = resolveThinking(next.thinking, resolved.model.thinkingLevels);
+        if (thinking.status === "exact" || thinking.status === "alias" || thinking.status === "fallback") {
+          if (thinking.level !== next.thinking) {
+            notes.push(
+              thinking.status === "fallback"
+                ? `thinking ${next.thinking} → ${thinking.level} (${thinking.reason})`
+                : `thinking ${next.thinking} → ${thinking.level}`,
+            );
+          }
+          next = { ...next, thinking: thinking.level };
+        } else if (thinking.status === "unsupported") {
+          notes.push(`thinking ${next.thinking} unsupported by ${resolved.model.label}; dropped`);
+          const { thinking: _drop, ...rest } = next;
+          next = rest;
+        }
+      }
+    } else if (resolved.status === "ambiguous") {
+      ambiguousModels = resolved.candidates.map((m) => m.label);
+      notes.push(`model ${next.model} is ambiguous; candidates: ${ambiguousModels.join(", ")}`);
+    } else {
+      notes.push(`model ${next.model} not found in catalog; left unchanged for skill verification`);
+    }
+  } else if (next.thinking) {
+    const thinking = resolveThinking(next.thinking);
+    if (thinking.status === "exact" || thinking.status === "alias" || thinking.status === "fallback") {
+      if (thinking.level !== next.thinking) notes.push(`thinking ${next.thinking} → ${thinking.level}`);
+      next = { ...next, thinking: thinking.level };
+    }
+  }
+
+  // Resolve each --reviewer-model id=model[:thinking] the same way as --model.
+  if (next.reviewerModels?.length && models.length > 0) {
+    const resolvedMappings: string[] = [];
+    for (const mapping of next.reviewerModels) {
+      const eq = mapping.indexOf("=");
+      if (eq <= 0) {
+        resolvedMappings.push(mapping);
+        continue;
+      }
+      const id = mapping.slice(0, eq);
+      const rawModel = mapping.slice(eq + 1);
+      const split = stripTrailingThinkingSuffix(rawModel);
+      const hit = resolveModelFromCatalog(split.model, models, primaryProvider);
+      if (hit.status === "exact" || hit.status === "unique") {
+        let thinking = split.thinking;
+        if (thinking) {
+          const t = resolveThinking(thinking, hit.model.thinkingLevels);
+          if (t.status === "exact" || t.status === "alias" || t.status === "fallback") thinking = t.level;
+          else thinking = undefined;
+        }
+        const token = thinking ? `${hit.model.label}:${thinking}` : hit.model.label;
+        if (token !== rawModel) notes.push(`reviewer-model ${id}: ${rawModel} → ${token}`);
+        resolvedMappings.push(`${id}=${token}`);
+      } else if (hit.status === "ambiguous") {
+        notes.push(`reviewer-model ${id}: ${rawModel} ambiguous; left unchanged`);
+        resolvedMappings.push(mapping);
+      } else {
+        notes.push(`reviewer-model ${id}: ${rawModel} not in catalog; left unchanged`);
+        resolvedMappings.push(mapping);
+      }
+    }
+    next = { ...next, reviewerModels: resolvedMappings };
+  }
+
+  return { parsed: next, notes, ...(ambiguousModels ? { ambiguousModels } : {}) };
+}

package/extensions/rv-semantic.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import { parseRvArgs } from "./rv-prompts.js";
 import { stripSemanticPhrases } from "./rv-semantic.js";
 

package/extensions/rv-semantic.ts

@@ -77,7 +77,10 @@ export function mergeSemanticIntoParsed(parsed: RvParsed, apply: SemanticApply):
   const out = { ...parsed };
   if (apply.mode) out.mode = apply.mode;
   if (apply.keepSession) out.keepSession = true;
-  if (apply.modelsOnly) out.modelsOnly = true;
+  if (apply.modelsOnly) {
+    out.modelsOnly = true;
+    out.strategy = "models";
+  }
   if (apply.noStream) out.noStream = true;
   return out;
 }
@@ -87,21 +90,52 @@ export function semanticCompletionItems(
   tail: string,
   headPrefix: string,
   head: string[],
+  rawHead: string[] = head,
 ): { 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 prepared = SEMANTIC_PHRASES.map((row) => {
     const value = row.completionValue(locale);
+    const candidates = [value, ...row.phrases].map((candidate) => candidate.toLowerCase().trim());
+    let consumedHeadTokens = 0;
+    // A multi-word phrase can span completed head tokens plus the in-progress tail
+    // (`@src code rev`). Replace that suffix rather than appending `code review`
+    // and producing `@src code code review`.
+    for (let count = head.length; count >= 1; count -= 1) {
+      const typed = [...head.slice(-count), tail]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase()
+        .trim();
+      if (typed && candidates.some((candidate) => candidate.startsWith(typed))) {
+        consumedHeadTokens = count;
+        break;
+      }
+    }
+    return { row, value, consumedHeadTokens };
+  });
+  const hasContextualPhrase = prepared.some((entry) => entry.consumedHeadTokens > 0);
+  const items: { value: string; label: string; description?: string }[] = [];
+
+  for (const { row, value, consumedHeadTokens } of prepared) {
     if (present.has(value.toLowerCase())) continue;
+    // Once a head+tail suffix identifies a phrase, suppress unrelated phrases
+    // that only happen to contain the short tail (e.g. every "... review").
+    if (hasContextualPhrase && consumedHeadTokens === 0) continue;
     const matches =
+      consumedHeadTokens > 0 ||
       !q ||
       value.toLowerCase().includes(q) ||
       value.toLowerCase().startsWith(q) ||
       row.phrases.some((p) => p.toLowerCase().startsWith(q) || p.toLowerCase().includes(q));
     if (!matches) continue;
+
+    const keptRawHead = consumedHeadTokens > 0
+      ? rawHead.slice(0, Math.max(0, rawHead.length - consumedHeadTokens))
+      : rawHead;
+    const replacementPrefix = keptRawHead.length ? `${keptRawHead.join(" ")} ` : "";
     items.push({
-      value: `${headPrefix}${value}`,
+      value: `${replacementPrefix}${value}`,
       label: value,
       description: row.completionDesc?.(locale),
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zephyrdeng/pi-review",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Isolated AI-powered code and plan reviews from the command line",
   "type": "module",
   "author": "ZephyrDeng <zephyrTang@aliyun.com>",
@@ -50,29 +50,41 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
       "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.80.7",
+    "@earendil-works/pi-tui": "^0.80.7",
     "@types/node": "^22.0.0",
     "husky": "^9.1.7",
-    "typescript": "^5.8.0"
+    "tsx": "^4.23.1",
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "prepare": "husky",
     "build": "tsc",
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && tsc --noEmit -p tsconfig.extension.json",
     "smoke": "node dist/cli.js --help >/dev/null",
-    "test": "npx --yes tsx --test src/args.test.ts src/cli-exit.test.ts src/child-process.test.ts src/review.meta.test.ts src/review-result.test.ts src/loop.test.ts src/meta-footer.test.ts src/prompt.test.ts src/skill-protocol.test.ts src/json-events.test.ts src/install-args.test.ts src/panel-aggregate.test.ts src/matcher.test.ts src/panel-config.test.ts src/panel-loop.test.ts src/panel-cli.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",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:rv": "vitest run extensions",
     "prepublishOnly": "npm run build",
     "pack:dry": "npm pack --dry-run"
   },
   "engines": {
     "node": ">=20"
+  },
+  "dependencies": {
+    "typebox": "^1.1.38"
   }
 }

package/resources/review-presets.json

@@ -1,9 +1,9 @@
 {
   "code": {
     "description": "Code review only: inspect provided files, diffs, or paths and return review conclusions without editing.",
-    "tools": ["read", "grep", "find", "ls", "bash"],
+    "tools": ["read", "grep", "find", "ls"],
     "thinking": "high",
-    "instructions": "Review code or code changes only. Do not edit, write, patch, format, commit, or otherwise mutate files. Use bash only for read-only inspection commands such as git diff, git status, git show, tests with explicit user permission, or listing files. Focus on correctness, regressions, security, concurrency, API contracts, edge cases, maintainability, and missing tests."
+    "instructions": "Review code or code changes only. Do not edit, write, patch, format, commit, or otherwise mutate files. Use the enabled read-only tools for inspection. Focus on correctness, regressions, security, concurrency, API contracts, edge cases, maintainability, and missing tests."
   },
   "plan": {
     "description": "High-level plan review with multiple expert lenses; output a decisive conclusion.",

package/resources/rv-model-priorities.json

@@ -1,17 +1,26 @@
 {
   "code": [
-    { "idContains": "gpt-5.5", "thinking": "xhigh" },
-    { "idContains": "glm-5.2", "thinking": "high" }
+    { "idContains": "claude-sonnet", "versionPrefer": "5", "thinking": "xhigh" },
+    { "idContains": "deepseek-v4-flash", "thinking": "xhigh" },
+    { "idContains": "glm-5.2", "thinking": "xhigh" },
+    { "idContains": "minimax-m3", "thinking": "xhigh" },
+    { "idContains": "grok-4.5", "thinking": "xhigh" },
+    { "idContains": "gpt-5.6-terra" },
+    { "idContains": "gpt-5.6-luna", "thinking": "xhigh" }
   ],
   "frontend": [
+    { "idContains": "claude" },
+    { "idContains": "gpt" },
     { "idContains": "kimi", "versionPrefer": "2.7" },
-    { "idContains": "claude-sonnet", "versionPrefer": "5" },
-    { "idContains": "minimax-m3" }
+    { "idContains": "minimax-m3", "thinking": "xhigh" }
   ],
   "plan": [
-    { "idContains": "claude-opus-4-8" },
-    { "idContains": "claude-opus-4", "versionPrefer": "8" },
-    { "idContains": "deepseek-v4-pro" },
-    { "idContains": "deepseek-v4" }
+    { "idContains": "gpt-5.6-sol", "thinking": "xhigh" },
+    { "idContains": "claude-opus-4-8", "thinking": "xhigh" },
+    { "idContains": "claude-opus-4", "versionPrefer": "8", "thinking": "xhigh" },
+    { "idContains": "claude-fable-5", "thinking": "xhigh" },
+    { "idContains": "glm-5.2", "thinking": "xhigh" },
+    { "idContains": "deepseek-v4-pro", "thinking": "xhigh" },
+    { "idContains": "grok-4.5", "thinking": "xhigh" }
   ]
-}
+}