pi-critique-model 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Noguerol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,215 @@
+<div align="center">
+
+![Critique banner](docs/banner.png)
+
+</div>
+
+# Critique — Adversarial Code Review for pi
+
+**Critique reviews the last work step with a separate model and feeds the review back to the working model as advisory feedback.** Two thinking machines face off — the working model produced a work step, and an independent reviewer picks it apart for correctness, robustness, maintainability and efficiency. The verdict comes back as structured Markdown: `APPROVED`, `APPROVED_WITH_SUGGESTIONS`, or `CHANGES_RECOMMENDED` — and the working model stays the final judge. The feedback is **non-mandatory**: it applies, partially applies, or rejects each point as it sees fit.
+
+---
+
+## Features
+
+- **Independent reviewer** — a separate model judges the work step from the serialized context, with no tools of its own (can't modify the codebase, can't see your secrets)
+- **Auto-detects the work step** — splits the session branch into *episodes* at user-message boundaries; the last episode containing tool calls or assistant output is the work step
+- **Token-budgeted context** — the user prompt, assistant messages, tool calls and tool results are truncated to a self-contained block so the reviewer sees what it needs without overflow
+- **Multi-step review** — review the last `N` episodes in one shot (`/critique 3`) to catch interactions across steps
+- **Focus note** — `/critique check the error handling` biases the review without limiting it; the reviewer still scans for everything
+- **Structured output** — fixed `Verdict / Issues / Suggestions / Summary` schema so the feedback is always actionable and machine-parseable
+- **Independent model picker** — `/critique config` lets you choose the reviewer; the default is a *different* model than the working one, ensuring a genuinely independent perspective
+- **Advisory injection** — on by default; toggle off (or use `/critique view`) to keep the review as read-only
+- **Cancelable loader** — in TUI mode, the review runs behind a loader that you can abort with `Esc`
+- **No provider surprises** — empty reviews are flagged, provider errors are surfaced as errors instead of silently producing nothing
+- **Persistent config** — `~/.pi/agent/critique.json` stores the model choice and auto-inject toggle across all projects
+
+## Install
+
+Critique is a [pi package](https://pi.dev/packages): one extension (`src/index.ts`) declared in `package.json`.
+
+```bash
+# From GitHub
+pi install git:github.com/noguerol/critique
+
+# Pin a tag/commit
+pi install git:github.com/noguerol/critique@v1.0.0
+
+# From npm
+pi install npm:pi-critique-model
+
+# Local checkout (development)
+pi install /path/to/critique
+
+# Try it for one run only
+pi -e git:github.com/noguerol/critique
+```
+
+```bash
+pi list                      # show installed packages
+pi remove npm:pi-critique-model
+```
+
+> **Security:** pi packages run with full system access — extensions execute arbitrary code. Install only packages you trust and review the source.
+
+**Requirements:** a working pi installation with at least two models configured (one is the *working* model, the other becomes the *reviewer*). Models can be from the same provider as long as they have different IDs.
+
+## Quick Start
+
+```
+/critique config        # (optional) pick a reviewer model — defaults to "different from the working one"
+...                     # let the main model do some work
+/critique               # review the last work step and feed the feedback back
+```
+
+The main model then sees the review appended to its next turn and decides what to apply. With auto-inject off (or `/critique view`), the review is only displayed to you — useful when you're just exploring whether to apply changes.
+
+To focus the review:
+
+```
+/critique check the error handling on the retry logic
+/critique 3                             # review the last 3 work steps
+/critique 2 look at the test coverage   # combine count + focus
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/critique` | Review the last work step and inject the feedback back into the working model |
+| `/critique <focus>` | Review the last work step with an additional focus note |
+| `/critique N` | Review the last `N` work steps (max 5) |
+| `/critique N <focus>` | Combine count and focus |
+| `/critique view` | Show the review only, without injecting it |
+| `/critique view <focus>` | View-only, with a focus note |
+| `/critique view N` | View-only, last `N` steps |
+| `/critique config` | Pick the critique model from pi's native active models and toggle auto-inject |
+
+**Argument parsing:**
+
+- A leading integer (`1`–`5`) sets the number of work steps to review.
+- `config` or `view` after the slash sets the mode.
+- Anything else is treated as a focus note and prepended to the reviewer prompt.
+
+## How It Works
+
+### 1. Extract the work step
+
+The session branch is split into *episodes* at user-message boundaries. The last episode containing tool calls or assistant output is the work step: the user request that triggered it, every tool call (with arguments), and every tool result (diffs, command output, errors). Content is truncated to a token budget so the reviewer sees a focused, self-contained context:
+
+| Field | Max chars |
+|-------|-----------|
+| User prompt | 12,000 |
+| Assistant text | 8,000 |
+| Tool args | 4,000 each |
+| Tool result | 8,000 each |
+| Total | 60,000 |
+
+Truncated content is marked with `… [truncated]` so the reviewer can tell what it did and didn't see.
+
+### 2. Ask the reviewer
+
+The critique model is called directly through `ctx.modelRegistry.complete()` with **no tools** — it only judges. The reviewer is told:
+
+- The work step inside `<work-step>` tags
+- An optional `<focus-note>` if you passed one
+- "Do not invent issues: if the work is correct, say so and keep suggestions minimal"
+
+It replies in a fixed Markdown structure:
+
+```
+## Verdict
+APPROVED | APPROVED_WITH_SUGGESTIONS | CHANGES_RECOMMENDED
+
+## Issues
+- [severity: critical|major|minor] description
+
+## Suggestions
+- concrete, actionable suggestion
+
+## Summary
+2-4 sentence overall assessment.
+```
+
+The reviewer is also told explicitly to base its judgment *only* on the provided work step, so a reviewer on a smaller/cheaper model still gives useful feedback.
+
+### 3. Inject the feedback
+
+The review is sent back to the working model as a follow-up user message:
+
+```
+[Critique — advisory review of your last work step]
+
+A separate reviewer model (`provider/model`) reviewed the work you just
+performed. This feedback is **advisory, not mandatory**: you are the final
+judge. Apply only the points that genuinely improve the work, and if you
+disagree with any of them, briefly explain why and continue.
+
+--- Review ---
+<the review>
+```
+
+The main model then has the freedom to apply, partially apply, or reject each point. If auto-inject is off, the review is only shown to you.
+
+## Model Selection
+
+`/critique config` opens the critic model picker. It only offers models with configured auth, **only** from pi's native model registry — the same list you see in `/model`. The picker shows at most ten entries at a time and scrolls past that.
+
+**Auto** (the default) prefers a *different* model than the working one, so the review is genuinely independent. If no second model is available, it falls back to the working model and warns you when it runs.
+
+If you pin a specific model that's later removed or uninstalled, critique silently falls back to Auto.
+
+If the critique model and the working model are the same, critique warns you — pick a different reviewer to get a genuinely independent second opinion.
+
+## Configuration
+
+The config is persisted as JSON at `~/.pi/agent/critique.json`:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4",
+  "autoInject": true
+}
+```
+
+- **`model`** — canonical `provider/modelId` of the reviewer. Empty string = Auto (different from working model).
+- **`autoInject`** — when `true`, the review is injected back into the working model. When `false`, the review is only displayed.
+
+The picker offers any model with configured auth that's available in pi's registry; the config persists per-machine (in `getAgentDir()`), shared across all projects.
+
+## Architecture
+
+```
+critique/
+├── package.json        # pi package manifest (pi-package)
+├── LICENSE             # MIT
+├── README.md
+├── docs/
+│   ├── banner.png      # wide README header
+│   └── preview.png     # npm pi.dev preview card
+├── screenshot.png      # full-res master
+└── src/
+    ├── index.ts        # /critique command surface, model picker, review UI (≈300 lines)
+    ├── config.ts       # persistence + model resolution: pinned, auto, fallback (≈90 lines)
+    ├── work-step.ts    # episode splitting + token-budgeted serialization (≈200 lines)
+    └── review.ts       # reviewer prompt + model call + injected-message builder (≈115 lines)
+```
+
+Four-file extension with zero external dependencies (only pi's bundled `@earendil-works/*` + Node built-ins):
+
+- **Episode splitter** — splits a session branch into user-message-bounded episodes, picks the last one with work
+- **Token budgeter** — hard caps per field, marks truncations so the reviewer knows what it didn't see
+- **Reviewer call** — tool-free `ctx.modelRegistry.complete()` with a structured system prompt
+- **Advisory formatter** — wraps the review in a "non-mandatory" envelope before injecting as a follow-up user message
+- **UI** — paginated TUI model picker (SelectList) + Markdown review viewer + cancelable BorderedLoader
+
+## Notes
+
+- The critique model runs with **no tools** and never touches the filesystem. It judges purely from the serialized work step (which includes the diffs and outputs of `edit`/`write`/`bash` calls).
+- In TUI mode the review runs behind a cancelable loader (Esc aborts) and `/critique view` opens a scrollable Markdown viewer. In RPC mode reviews are surfaced through notifications; print mode logs them to stdout.
+- Provider errors (bad keys, insufficient balance, rate limit) are surfaced as errors instead of silently producing empty reviews.
+- Reviews are capped at 16,000 chars to keep the injected follow-up reasonable; longer reviews are truncated with `… [review truncated]`.
+
+## License
+
+[MIT](LICENSE) © Javier Noguerol

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "pi-critique-model",
+  "version": "1.0.0",
+  "description": "A pi extension that reviews the last work step with a separate model and feeds the review back to the working model as advisory feedback. Independent reviewer with tool-free analysis, structured Markdown verdict (APPROVED / APPROVED_WITH_SUGGESTIONS / CHANGES_RECOMMENDED) and a token-budgeted context.",
+  "keywords": [
+    "pi-package",
+    "review",
+    "critique",
+    "feedback",
+    "code-review",
+    "second-opinion",
+    "advisory"
+  ],
+  "author": "Javier Noguerol <https://github.com/noguerol>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/noguerol/critique"
+  },
+  "homepage": "https://github.com/noguerol/critique",
+  "bugs": {
+    "url": "https://github.com/noguerol/critique/issues"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "files": [
+    "src"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  }
+}

package/src/config.ts

@@ -0,0 +1,89 @@
+/**
+ * Critique — configuration.
+ *
+ * The critique config is a small JSON file in the pi user directory
+ * (getAgentDir()/critique.json), shared across projects.
+ */
+
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface CritiqueConfig {
+  /** Canonical "provider/modelId" of the critique model. Empty string = auto. */
+  model: string;
+  /** Inject the review back into the working model automatically. */
+  autoInject: boolean;
+}
+
+export const DEFAULT_CONFIG: CritiqueConfig = {
+  model: "",
+  autoInject: true,
+};
+
+export function configFilePath(): string {
+  return join(getAgentDir(), "critique.json");
+}
+
+export function loadConfig(): CritiqueConfig {
+  try {
+    const raw = JSON.parse(readFileSync(configFilePath(), "utf8")) as Partial<CritiqueConfig>;
+    return {
+      model: typeof raw.model === "string" ? raw.model : DEFAULT_CONFIG.model,
+      autoInject:
+        typeof raw.autoInject === "boolean" ? raw.autoInject : DEFAULT_CONFIG.autoInject,
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(config: CritiqueConfig): void {
+  const path = configFilePath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+export function modelLabel(model: Model): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/**
+ * Models the user can pick in /critique config: the session-scoped set when
+ * scoping is configured, otherwise the full available catalogue. Only models
+ * with configured auth are offered.
+ */
+export function pickableModels(ctx: ExtensionContext): Model[] {
+  const scoped = (ctx.scopedModels ?? []).map((entry) => entry.model);
+  const candidates = scoped.length > 0 ? scoped : ctx.modelRegistry.getAvailable();
+  return candidates.filter((model) => ctx.modelRegistry.hasConfiguredAuth(model));
+}
+
+/**
+ * Resolve the model that runs the critique.
+ *
+ * - Pinned ("provider/modelId"): used when it exists and has configured auth.
+ * - Auto (""): prefer a different model than the working one, so the review is
+ *   independent; fall back to the working model when nothing else is usable.
+ */
+export function resolveCritiqueModel(
+  ctx: ExtensionContext,
+  config: CritiqueConfig,
+): Model | undefined {
+  if (config.model) {
+    const slash = config.model.indexOf("/");
+    const provider = slash >= 0 ? config.model.slice(0, slash) : config.model;
+    const id = slash >= 0 ? config.model.slice(slash + 1) : config.model;
+    const model = ctx.modelRegistry.find(provider, id);
+    return model && ctx.modelRegistry.hasConfiguredAuth(model) ? model : undefined;
+  }
+
+  const candidates = pickableModels(ctx);
+  const working = ctx.model;
+  const different = candidates.find(
+    (model) => !working || model.provider !== working.provider || model.id !== working.id,
+  );
+  return different ?? working ?? candidates[0];
+}

package/src/index.ts

@@ -0,0 +1,307 @@
+/**
+ * Critique — a pi extension that reviews the last work step with a separate
+ * model and feeds the review back to the working model as advisory feedback.
+ *
+ * Commands:
+ *   /critique                Review the last work step and inject the feedback
+ *   /critique <focus>        ... focusing the review on <focus>
+ *   /critique N              ... reviewing the last N work steps (max 5)
+ *   /critique view [N]       Show the review only, without injecting it
+ *   /critique config         Choose the critique model from pi's active models
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  BorderedLoader,
+  DynamicBorder,
+  getMarkdownTheme,
+  getSelectListTheme,
+} from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem, SelectItem } from "@earendil-works/pi-tui";
+import { Container, Markdown, matchesKey, SelectList, Spacer, Text } from "@earendil-works/pi-tui";
+
+import {
+  loadConfig,
+  modelLabel,
+  pickableModels,
+  resolveCritiqueModel,
+  saveConfig,
+} from "./config.ts";
+import { extractWorkSteps, formatWorkSteps } from "./work-step.ts";
+import { buildInjectedMessage, runCritique } from "./review.ts";
+
+type Mode = "config" | "review" | "view";
+
+interface ParsedArgs {
+  mode: Mode;
+  count: number;
+  focus: string;
+}
+
+function parseArgs(raw: string): ParsedArgs {
+  const trimmed = raw.trim();
+  let mode: Mode = "review";
+  let rest = trimmed;
+
+  const first = rest.split(/\s+/)[0];
+  if (first === "config") return { mode: "config", count: 1, focus: "" };
+  if (first === "view") {
+    mode = "view";
+    rest = rest.slice("view".length).trim();
+  }
+
+  let count = 1;
+  const countMatch = rest.match(/^(\d+)(?:\s+(.*))?$/);
+  if (countMatch) {
+    count = Math.min(5, Math.max(1, parseInt(countMatch[1], 10)));
+    rest = (countMatch[2] ?? "").trim();
+  }
+
+  return { mode, count, focus: rest };
+}
+
+/** Run the review task with a cancelable loader in TUI mode. */
+async function runWithLoader(
+  ctx: ExtensionCommandContext,
+  task: (signal: AbortSignal | undefined) => Promise<string | null>,
+): Promise<string | null> {
+  if (ctx.mode !== "tui") {
+    try {
+      return await task(undefined);
+    } catch (error) {
+      ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      return null;
+    }
+  }
+  return ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+    const loader = new BorderedLoader(tui, theme, "Running critique...");
+    loader.onAbort = () => done(null);
+    task(loader.signal)
+      .then((result) => done(result))
+      .catch((error) => {
+        console.error("[critique] review failed:", error);
+        done(null);
+      });
+    return loader;
+  });
+}
+
+/** How many models the picker shows at once; it scrolls beyond that. */
+const MAX_VISIBLE_MODELS = 10;
+
+/**
+ * Paginated model picker (TUI only). Shows at most MAX_VISIBLE_MODELS entries
+ * at a time with a scroll indicator; ↑/↓ move, Enter selects, Esc cancels.
+ */
+function pickModel(
+  ctx: ExtensionCommandContext,
+  title: string,
+  items: SelectItem[],
+  preselect?: string,
+): Promise<string | undefined> {
+  return ctx.ui.custom<string | undefined>((_tui, theme, _kb, done) => {
+    const list = new SelectList(items, MAX_VISIBLE_MODELS, getSelectListTheme(), {
+      minPrimaryColumnWidth: 24,
+      maxPrimaryColumnWidth: 48,
+    });
+    list.onSelect = (item) => done(item.value);
+    list.onCancel = () => done(undefined);
+    if (preselect) {
+      const index = items.findIndex((item) => item.value === preselect);
+      if (index >= 0) list.setSelectedIndex(index);
+    }
+
+    const container = new Container();
+    const border = new DynamicBorder((s: string) => theme.fg("accent", s));
+    container.addChild(border);
+    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    container.addChild(new Text(theme.fg("dim", "↑/↓ move · Enter select · Esc cancel"), 1, 0));
+    container.addChild(new Spacer(1));
+    container.addChild(list);
+    container.addChild(new Spacer(1));
+    container.addChild(border);
+
+    return {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => list.handleInput(data),
+    };
+  });
+}
+
+/** Show the review in a scrollable markdown viewer (TUI only). */
+async function showMarkdown(ctx: ExtensionCommandContext, title: string, markdown: string): Promise<void> {
+  await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const container = new Container();
+    const border = new DynamicBorder((s: string) => theme.fg("accent", s));
+    const mdTheme = getMarkdownTheme();
+
+    container.addChild(border);
+    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    container.addChild(new Markdown(markdown, 1, 1, mdTheme));
+    container.addChild(new Text(theme.fg("dim", "Press Enter or Esc to close"), 1, 0));
+    container.addChild(border);
+
+    return {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => {
+        if (matchesKey(data, "enter") || matchesKey(data, "escape")) {
+          done(undefined);
+        }
+      },
+    };
+  });
+}
+
+async function runReview(pi: ExtensionAPI, ctx: ExtensionCommandContext, parsed: ParsedArgs): Promise<void> {
+  const config = loadConfig();
+
+  // Make sure any in-flight agent run has fully settled so the session tree
+  // contains the complete work step (resolves immediately when idle).
+  await ctx.waitForIdle();
+
+  const branch = ctx.sessionManager.getBranch();
+  if (branch.length === 0) {
+    ctx.ui.notify("No session content to critique yet.", "warning");
+    return;
+  }
+
+  const steps = extractWorkSteps(branch, parsed.count);
+  if (steps.length === 0) {
+    ctx.ui.notify("No work step found — the session has no assistant tool activity to review.", "warning");
+    return;
+  }
+  if (steps.length < parsed.count) {
+    ctx.ui.notify(`Only ${steps.length} work step(s) found; reviewing those.`, "info");
+  }
+
+  const model = resolveCritiqueModel(ctx, config);
+  if (!model) {
+    ctx.ui.notify("No critique model available (none with configured auth). Run /critique config to pick one.", "error");
+    return;
+  }
+
+  if (ctx.model && modelLabel(model) === modelLabel(ctx.model)) {
+    ctx.ui.notify("Note: the critique model is the same as the working model. Run /critique config to pick a different one.", "warning");
+  }
+
+  const workText = formatWorkSteps(steps);
+  const review = await runWithLoader(ctx, (signal) => runCritique(ctx, model, workText, parsed.focus, signal));
+
+  if (review === null) {
+    ctx.ui.notify("Critique cancelled.", "info");
+    return;
+  }
+  if (!review) {
+    ctx.ui.notify("The critique model returned an empty review.", "warning");
+    return;
+  }
+
+  const label = modelLabel(model);
+  if (parsed.mode === "view" || !config.autoInject) {
+    if (ctx.mode === "tui") {
+      await showMarkdown(ctx, "Critique review", review);
+    } else if (ctx.hasUI) {
+      ctx.ui.notify(`Critique (${label}):\n${review.slice(0, 1000)}`, "info");
+    } else {
+      console.log(`[critique] Review from ${label}:\n${review}`);
+    }
+    return;
+  }
+
+  const injected = buildInjectedMessage(label, review);
+  pi.sendUserMessage(injected, { deliverAs: "followUp" });
+  ctx.ui.notify(`Critique feedback from ${label} sent back to the working model.`, "info");
+}
+
+async function handleConfig(ctx: ExtensionCommandContext): Promise<void> {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("/critique config requires interactive or RPC mode.", "error");
+    return;
+  }
+
+  const config = loadConfig();
+  const models = pickableModels(ctx);
+
+  const currentModel = config.model || "auto (a different model than the working one)";
+  ctx.ui.notify(
+    `Critique config — model: ${currentModel} | auto-inject: ${config.autoInject ? "on" : "off"}`,
+    "info",
+  );
+
+  if (models.length === 0) {
+    ctx.ui.notify("No models with configured auth are available to pick.", "error");
+    return;
+  }
+
+  const items: SelectItem[] = [
+    {
+      value: "",
+      label: "Auto",
+      description: "Different model than the working one (fallback: current model)",
+    },
+    ...models.map((model) => ({
+      value: modelLabel(model),
+      label: model.name,
+      description: `${model.provider}/${model.id}`,
+    })),
+  ];
+
+  let modelChoice: string | undefined;
+  if (ctx.mode === "tui") {
+    modelChoice = await pickModel(ctx, "Critique model", items, config.model);
+    if (modelChoice === undefined) {
+      ctx.ui.notify("Config cancelled.", "info");
+      return;
+    }
+  } else {
+    // RPC mode: ctx.ui.custom() is unavailable, fall back to the built-in select.
+    const choice = await ctx.ui.select(
+      "Critique model:",
+      items.map((item) => `${item.label} (${item.description})`),
+    );
+    if (choice === undefined) {
+      ctx.ui.notify("Config cancelled.", "info");
+      return;
+    }
+    const selected = items.find((item) => `${item.label} (${item.description})` === choice);
+    modelChoice = selected?.value ?? "";
+  }
+  config.model = modelChoice;
+
+  const autoInject = await ctx.ui.confirm(
+    "Auto-inject feedback?",
+    "Inject the critique review back into the working model automatically? Choose No to only display reviews (/critique view always only displays).",
+  );
+  config.autoInject = autoInject;
+
+  saveConfig(config);
+  ctx.ui.notify(
+    `Critique config saved — model: ${config.model || "auto"} | auto-inject: ${config.autoInject ? "on" : "off"}`,
+    "info",
+  );
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("critique", {
+    description:
+      "Review the last work step with a separate model and feed the feedback back to the working model",
+    getArgumentCompletions: (prefix: string): AutocompleteItem[] | null => {
+      const items: AutocompleteItem[] = [
+        { value: "config", label: "config" },
+        { value: "view", label: "view" },
+      ];
+      const filtered = items.filter((item) => item.value.startsWith(prefix));
+      return filtered.length > 0 ? filtered : null;
+    },
+    handler: async (args, ctx) => {
+      const parsed = parseArgs(args);
+      if (parsed.mode === "config") {
+        await handleConfig(ctx);
+        return;
+      }
+      await runReview(pi, ctx, parsed);
+    },
+  });
+}

package/src/review.ts

@@ -0,0 +1,113 @@
+/**
+ * Critique — reviewer prompt and model call.
+ *
+ * The critique model runs with no tools: it judges the work step purely from
+ * the serialized context. Its output is structured Markdown that is then
+ * injected back into the working model as advisory feedback.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type Message, type Model, uuidv7 } from "@earendil-works/pi-ai";
+
+const MAX_REVIEW_CHARS = 16_000;
+
+export const REVIEWER_SYSTEM_PROMPT = [
+  "You are an independent code reviewer. Another agent just performed work in a project session, and your job is to judge whether that work is correct and whether it can be improved.",
+  "You have no tools: base your review exclusively on the work step provided below.",
+  "",
+  "Review for:",
+  "1. Correctness — does the work satisfy the user's request? Are there bugs, errors, or gaps?",
+  "2. Robustness — edge cases, error handling, security, and failure modes.",
+  "3. Maintainability — naming, structure, duplication, readability, and consistency.",
+  "4. Efficiency — wasted work, repeated computation, or unnecessarily large changes.",
+  "",
+  "Be specific and concrete. Reference the actual tool calls and results (files, lines, commands) from the work step. Do not invent issues: if the work is correct, say so and keep suggestions minimal.",
+  "If the work step was truncated, note it and review only what is visible.",
+  "",
+  "Reply using EXACTLY this Markdown structure:",
+  "",
+  "## Verdict",
+  "APPROVED | APPROVED_WITH_SUGGESTIONS | CHANGES_RECOMMENDED",
+  "",
+  "## Issues",
+  "- [severity: critical|major|minor] description",
+  "",
+  "## Suggestions",
+  "- concrete, actionable suggestion",
+  "",
+  "## Summary",
+  "2-4 sentence overall assessment.",
+].join("\n");
+
+export function buildReviewPrompt(workText: string, focusNote: string): string {
+  const sections: string[] = [];
+  sections.push("Review the most recent work performed in this project session.");
+  sections.push("");
+  sections.push("<work-step>");
+  sections.push(workText);
+  sections.push("</work-step>");
+  if (focusNote) {
+    sections.push("");
+    sections.push("<focus-note>");
+    sections.push(focusNote);
+    sections.push("</focus-note>");
+    sections.push("Pay special attention to the focus note above, but do not limit your review to it.");
+  }
+  return sections.join("\n");
+}
+
+/**
+ * Run the critique model. Returns the review text, or null when aborted.
+ */
+export async function runCritique(
+  ctx: ExtensionContext,
+  model: Model,
+  workText: string,
+  focusNote: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  const userMessage: Message = {
+    role: "user",
+    content: [{ type: "text", text: buildReviewPrompt(workText, focusNote) }],
+    timestamp: Date.now(),
+  };
+
+  const response = await ctx.modelRegistry.complete(
+    model,
+    { systemPrompt: REVIEWER_SYSTEM_PROMPT, messages: [userMessage] },
+    { signal, cacheRetention: "none", sessionId: uuidv7() },
+  );
+
+  if (response.stopReason === "aborted") return null;
+  if (response.stopReason === "error") {
+    throw new Error(`Critique model ${model.provider}/${model.id} failed: ${response.errorMessage ?? "unknown error"}`);
+  }
+
+  const review = response.content
+    .filter((block): block is { type: "text"; text: string } => block.type === "text")
+    .map((block) => block.text)
+    .join("\n")
+    .trim();
+
+  // Cap the review so the injected message stays reasonable.
+  return review.length > MAX_REVIEW_CHARS
+    ? `${review.slice(0, MAX_REVIEW_CHARS)}… [review truncated]`
+    : review;
+}
+
+/**
+ * Message injected back into the main agent. Shaped as advisory feedback:
+ * the working model is the final judge and may accept, partially accept, or
+ * reject the critique — the feedback is not a mandatory instruction.
+ */
+export function buildInjectedMessage(critiqueModel: string, review: string): string {
+  return [
+    "[Critique — advisory review of your last work step]",
+    "",
+    `A separate reviewer model (\`${critiqueModel}\`) reviewed the work you just performed. This feedback is **advisory, not mandatory**: you are the final judge. Apply only the points that genuinely improve the work, and if you disagree with any of them, briefly explain why and continue.`,
+    "",
+    "--- Review ---",
+    "",
+    review,
+  ].join("\n");
+}

package/src/work-step.ts

@@ -0,0 +1,203 @@
+/**
+ * Critique — work-step extraction.
+ *
+ * A "work step" is an episode: everything the agent did in response to the
+ * latest user request — all assistant messages, tool calls, and tool results
+ * up to the next user message. The last work step is the last episode that
+ * contains actual work (tool calls or assistant output).
+ */
+
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
+export interface WorkStepToolCall {
+  id: string;
+  name: string;
+  args: string;
+}
+
+export interface WorkStepToolResult {
+  callId: string;
+  toolName: string;
+  content: string;
+  isError: boolean;
+}
+
+export interface WorkStep {
+  userPrompt: string;
+  assistantText: string;
+  toolCalls: WorkStepToolCall[];
+  toolResults: WorkStepToolResult[];
+  modelLabel: string | undefined;
+  /** True when the episode contains tool calls or assistant text. */
+  hasWork: boolean;
+}
+
+const MAX_USER_PROMPT = 12_000;
+const MAX_ASSISTANT_TEXT = 8_000;
+const MAX_TOOL_ARGS = 4_000;
+const MAX_TOOL_RESULT = 8_000;
+const MAX_TOTAL = 60_000;
+
+export function truncateText(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}… [truncated]`;
+}
+
+/** Permissive view of an AgentMessage so extraction survives schema drift. */
+interface LooseMessage {
+  role?: string;
+  content?: unknown;
+  toolCallId?: string;
+  toolName?: string;
+  isError?: boolean;
+  provider?: string;
+  model?: string;
+}
+
+interface ContentBlock {
+  type?: string;
+  text?: string;
+  name?: string;
+  id?: string;
+  arguments?: unknown;
+}
+
+function contentBlocks(content: unknown): ContentBlock[] {
+  if (!Array.isArray(content)) return [];
+  return content.filter((block): block is ContentBlock => !!block && typeof block === "object");
+}
+
+function contentText(content: unknown): string {
+  if (typeof content === "string") return content.trim();
+  return contentBlocks(content)
+    .filter((block) => block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text as string)
+    .join("\n")
+    .trim();
+}
+
+function toolCallsOf(content: unknown): WorkStepToolCall[] {
+  return contentBlocks(content)
+    .filter((block) => block.type === "toolCall" && typeof block.name === "string")
+    .map((block) => ({
+      id: block.id ?? "",
+      name: block.name as string,
+      args: JSON.stringify(block.arguments ?? {}),
+    }));
+}
+
+function messageOf(entry: SessionEntry): LooseMessage {
+  return entry.message as unknown as LooseMessage;
+}
+
+function isUserEntry(entry: SessionEntry): boolean {
+  return entry.type === "message" && messageOf(entry).role === "user";
+}
+
+/**
+ * Extract the most recent work steps from a session branch (root → leaf).
+ * Returns up to `count` steps, newest last. Episodes without work (e.g. a
+ * bare "/critique" prompt) are skipped.
+ */
+export function extractWorkSteps(branch: SessionEntry[], count: number): WorkStep[] {
+  // Split the branch into episodes at user-message boundaries.
+  const boundaries: number[] = [];
+  for (let i = 0; i < branch.length; i++) {
+    if (isUserEntry(branch[i])) boundaries.push(i);
+  }
+  boundaries.push(branch.length);
+
+  const steps: WorkStep[] = [];
+  for (let k = boundaries.length - 2; k >= 0 && steps.length < count; k--) {
+    const start = boundaries[k];
+    const end = boundaries[k + 1];
+    const step = buildStep(branch, start, end);
+    if (step.hasWork) steps.push(step);
+  }
+  return steps;
+}
+
+function buildStep(branch: SessionEntry[], start: number, end: number): WorkStep {
+  const userPrompt = contentText(messageOf(branch[start]).content);
+  const toolCalls: WorkStepToolCall[] = [];
+  const toolResults: WorkStepToolResult[] = [];
+  const textParts: string[] = [];
+  let modelLabel: string | undefined;
+
+  for (let i = start + 1; i < end; i++) {
+    const entry = branch[i];
+    if (entry.type !== "message") continue;
+    const message = messageOf(entry);
+
+    if (message.role === "assistant") {
+      toolCalls.push(...toolCallsOf(message.content));
+      const text = contentText(message.content);
+      if (text) textParts.push(text);
+      if (message.provider && message.model) {
+        modelLabel = `${message.provider}/${message.model}`;
+      } else if (message.model) {
+        modelLabel = message.model;
+      }
+    } else if (message.role === "toolResult") {
+      const content = contentText(message.content);
+      if (message.toolCallId && (content.length > 0 || message.isError)) {
+        toolResults.push({
+          callId: message.toolCallId,
+          toolName: message.toolName ?? "tool",
+          content,
+          isError: !!message.isError,
+        });
+      }
+    }
+  }
+
+  const hasWork = toolCalls.length > 0 || textParts.length > 0;
+  return {
+    userPrompt,
+    assistantText: textParts.join("\n\n"),
+    toolCalls,
+    toolResults,
+    modelLabel,
+    hasWork,
+  };
+}
+
+/** Render work steps as a self-contained text block for the reviewer model. */
+export function formatWorkSteps(steps: WorkStep[]): string {
+  const sections = steps.map((step, index) => {
+    const position = steps.length - index;
+    const lines: string[] = [];
+    lines.push(`### Work step ${position}${step.modelLabel ? ` (model: ${step.modelLabel})` : ""}`);
+
+    if (step.userPrompt) {
+      lines.push(`\n**User request:**\n${truncateText(step.userPrompt, MAX_USER_PROMPT)}`);
+    }
+    if (step.assistantText) {
+      lines.push(`\n**Assistant messages:**\n${truncateText(step.assistantText, MAX_ASSISTANT_TEXT)}`);
+    }
+    if (step.toolCalls.length > 0) {
+      lines.push(`\n**Tool calls:**`);
+      for (const call of step.toolCalls) {
+        lines.push(`- \`${call.name}(${truncateText(call.args, MAX_TOOL_ARGS)})\``);
+      }
+    }
+    if (step.toolResults.length > 0) {
+      lines.push(`\n**Tool results:**`);
+      for (const result of step.toolResults) {
+        const flag = result.isError ? " (ERROR)" : "";
+        lines.push(`- \`${result.toolName}\`${flag}:`);
+        const body = truncateText(result.content, MAX_TOOL_RESULT);
+        for (const line of body.split("\n")) {
+          lines.push(`  ${line}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  });
+
+  let output = sections.join("\n\n---\n\n");
+  if (output.length > MAX_TOTAL) {
+    output = `${output.slice(0, MAX_TOTAL)}… [work step truncated]`;
+  }
+  return output;
+}