@geminixiang/pi-simplify 0.0.6 → 0.0.8

package/prompt.ts

@@ -0,0 +1,93 @@
+export const SIMPLIFY_PROMPT = `# Simplify: Review Changed Code for Reuse, Quality, and Efficiency
+
+You are a code review assistant. Review the changed code along three axes — **Reuse**, **Quality**, and **Efficiency** — and surface concrete fixes.
+
+Match the user's language for candidate reasons and summaries; if the user's request is in Chinese, write the candidate \`reason\` fields in Chinese.
+
+## What to Find
+
+### A. Reuse (Confirm Before Replacing)
+
+Before flagging, **search the codebase** (utility directories, shared modules, files adjacent to the change) for existing helpers. Quote the existing symbol you'd use.
+
+- **Duplicates an existing function**: a newly written helper does what an existing one already does
+- **Inline logic that has a utility**: hand-rolled string manipulation, manual path handling, custom env checks, ad-hoc type guards
+- **Reinvented framework primitive**: re-implementing something the language/stdlib/framework already provides
+
+### B. Quality
+
+#### B1. Dead Code (Safe to Delete)
+- Unused exports, orphan files, zombie variables, empty try/catch/if blocks
+
+#### B2. Debug Remnants (Safe to Delete)
+- \`console.log\` / \`console.warn\` / \`console.error\`, \`debugger\`, temporary feature flags, stale TODO comments
+
+#### B3. Commented-out Code (Review)
+- Old logic left in comments, disabled features, uncustomized templates
+
+#### B4. Over-engineering (Confirm)
+- Abstractions created "for future use" but unused, single-call-site helpers that should be inlined, useless indirection
+
+#### B5. Hacky Patterns (Confirm)
+- **Redundant state**: state that duplicates other state, cached values that could be derived, observers that could be direct calls
+- **Parameter sprawl**: piling new parameters onto a function instead of restructuring
+- **Copy-paste with variation**: near-duplicate blocks that should share an abstraction
+- **Leaky abstractions**: exposing internals or breaking existing boundaries
+- **Stringly-typed code**: raw strings where an existing constant/enum/union exists
+- **Unnecessary wrapper elements**: JSX/DOM wrappers that add no layout value
+- **Nested conditionals**: ternary chains or if/else nested 3+ levels deep — flatten with early returns or a lookup table
+- **Useless comments**: comments restating WHAT the code does, narrating the change, or referencing the task/caller — keep only non-obvious WHY
+
+### C. Efficiency (Confirm)
+
+- **Unnecessary work**: redundant computations, repeated file reads, duplicate API calls, N+1 patterns
+- **Missed concurrency**: independent operations run sequentially when they could run in parallel
+- **Hot-path bloat**: blocking work added to startup or per-request/per-render hot paths
+- **Recurring no-op updates**: state writes inside loops/intervals/handlers that fire unconditionally — add a change-detection guard
+- **Unnecessary existence checks**: pre-checking file/resource existence before operating (TOCTOU) — operate directly and handle the error
+- **Memory**: unbounded data structures, missing cleanup, event listener leaks
+- **Overly broad operations**: reading whole files when a slice would do, loading all items when filtering for one
+
+## How to Analyze
+
+1. Unless the user explicitly asks for a folder/snapshot review, run \`git diff\` to see what changed. For folder/snapshot review, read the files directly under the requested paths and ignore files outside that scope.
+2. For each change or in-scope snapshot finding, classify as **Essential** / **Residual** / **Legacy** (don't flag legacy code unless the diff touches it; in folder/snapshot mode, flag only in-scope code that is clearly removable or simplifiable).
+3. For each finding:
+   - Identify exact file and line(s)
+   - Assign **category** (reuse / quality / efficiency) and **risk**
+   - State the concrete fix (which existing utility to call, which lines to delete, how to parallelize, etc.)
+
+## Risk Levels
+
+- **safe**: Definitely apply (dead code, debug remnants)
+- **confirm**: Apply after user confirms (reuse swaps, over-engineering, hacky patterns, efficiency fixes)
+- **review**: User should look first (commented-out code, ambiguous cases)
+
+## Rules
+
+1. When in doubt, mark as "confirm" or "review" — don't change without consent.
+2. For reuse findings, name the existing symbol/file you'd swap to.
+3. For efficiency findings, briefly justify the win (e.g., "N+1 → single query", "sequential awaits → Promise.all").
+4. Don't flag necessary code just because it's simple.
+5. Respect existing abstraction boundaries.
+6. Be especially careful with:
+   - Error handling code
+   - Security-related logic
+   - Code that looks "unused" but is called via reflection/eval
+   - Database migration files
+
+## Output Format (REQUIRED)
+
+When analysis is complete, call the \`simplify_candidates\` tool exactly once as your final action. Put ALL candidates in that tool call.
+
+Field notes:
+- \`category\` — one of: "reuse", "quality", "efficiency"
+- \`risk\` — one of: "safe", "confirm", "review"
+- \`file\` — repository-relative path, no backticks, no markdown
+- \`lines\` — line number or range ("42" or "42-57"); empty string if unknown
+- \`reason\` — single plain-text sentence stating the concrete fix
+- \`action\` — one of: "delete", "inline", "refactor", "parallelize"
+
+If there are no candidates, call \`simplify_candidates\` with an empty \`candidates\` array.
+Do NOT write a prose-only final answer; the extension relies on the tool result.
+`;

package/selector.ts

@@ -0,0 +1,176 @@
+import { getSelectListTheme, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  matchesKey,
+  Key,
+  SelectList,
+  wrapTextWithAnsi,
+  type SelectItem,
+} from "@earendil-works/pi-tui";
+
+import type { Action, SimplifyResult } from "./types.js";
+
+const RISK_CONFIG = {
+  safe: { label: "Safe to apply" },
+  confirm: { label: "Needs confirmation" },
+  review: { label: "Needs review" },
+} as const;
+
+const ACTION_LABEL: Record<Action, string> = {
+  delete: "Delete code",
+  inline: "Inline code",
+  refactor: "Refactor code",
+  parallelize: "Run work in parallel",
+};
+
+export async function showCandidateSelector(
+  ctx: ExtensionCommandContext,
+  candidates: SimplifyResult[],
+): Promise<SimplifyResult[]> {
+  if (candidates.length === 0) return [];
+
+  const safeCandidates = candidates.filter((c) => c.risk === "safe");
+  const confirmCandidates = candidates.filter((c) => c.risk === "confirm");
+  const reviewCandidates = candidates.filter((c) => c.risk === "review");
+
+  const sections = [
+    { key: "safe" as const, items: safeCandidates },
+    { key: "confirm" as const, items: confirmCandidates },
+    { key: "review" as const, items: reviewCandidates },
+  ]
+    .map(({ key, items }) => ({ key, items, config: RISK_CONFIG[key], total: items.length }))
+    .filter((s) => s.total > 0);
+
+  const selectableItems = sections.flatMap((section) =>
+    section.items.map((candidate) => ({ section, candidate })),
+  );
+
+  const listItems: SelectItem[] = selectableItems.map(({ section, candidate }, index) => ({
+    value: String(index),
+    label: "",
+    description: `${section.config.label} · ${ACTION_LABEL[candidate.action]}`,
+  }));
+
+  const selectedSet = new Set<number>();
+  selectableItems.forEach(({ candidate }, index) => {
+    if (candidate.risk === "safe") selectedSet.add(index);
+  });
+
+  const maxVisible = 8;
+  let cursorPos = 0;
+
+  const getSelectListStartIndex = (selectedIndex: number) =>
+    Math.max(
+      0,
+      Math.min(selectedIndex - Math.floor(maxVisible / 2), selectableItems.length - maxVisible),
+    );
+
+  const result = await ctx.ui.custom<SimplifyResult[]>((tui, theme, _keybindings, done) => {
+    const updateListLabel = (index: number) => {
+      const item = listItems[index];
+      const { candidate } = selectableItems[index];
+      const checkbox = selectedSet.has(index) ? "[x]" : "[ ]";
+      const location = candidate.lines ? `${candidate.file}:${candidate.lines}` : candidate.file;
+      item.label = `${checkbox} ${location}`;
+    };
+    const updateAllListLabels = () => listItems.forEach((_item, index) => updateListLabel(index));
+
+    updateAllListLabels();
+
+    const selectList = new SelectList(listItems, maxVisible, getSelectListTheme());
+    selectList.onSelectionChange = (item) => {
+      cursorPos = Number(item.value);
+    };
+    selectList.onCancel = () => done([]);
+
+    return {
+      render(width: number) {
+        selectList.setSelectedIndex(cursorPos);
+
+        const lines: string[] = [];
+        lines.push(theme.bold("Simplify: Select findings to apply"));
+        lines.push(
+          theme.fg(
+            "muted",
+            `Found ${candidates.length} candidates (${safeCandidates.length} safe, ${confirmCandidates.length} confirm, ${reviewCandidates.length} review)`,
+          ),
+        );
+        lines.push("");
+
+        const listLines = selectList.render(width);
+        const selectedLineIndex = cursorPos - getSelectListStartIndex(cursorPos);
+        const current = selectableItems[cursorPos]?.candidate;
+        for (const [lineIndex, line] of listLines.entries()) {
+          lines.push(line);
+          if (lineIndex !== selectedLineIndex || !current) continue;
+
+          const detailIndent = "    ";
+          const detailPrefix = `${detailIndent}│ `;
+          const location = current.lines ? `${current.file}:${current.lines}` : current.file;
+          lines.push(theme.fg("borderMuted", `${detailIndent}┌─ recommendation`));
+          lines.push(
+            ...wrapTextWithAnsi(current.reason, Math.max(1, width - detailPrefix.length)).map(
+              (wrappedLine) => theme.fg("muted", `${detailPrefix}${wrappedLine}`),
+            ),
+          );
+          lines.push(theme.fg("muted", `${detailPrefix}`));
+          lines.push(theme.fg("muted", `${detailPrefix}File: ${location}`));
+          lines.push(
+            theme.fg("muted", `${detailPrefix}Review: ${RISK_CONFIG[current.risk].label}`),
+          );
+          lines.push(theme.fg("muted", `${detailPrefix}Kind: ${current.category}`));
+          lines.push(theme.fg("muted", `${detailPrefix}Fix: ${ACTION_LABEL[current.action]}`));
+          lines.push(theme.fg("borderMuted", `${detailIndent}└─ space selects this fix`));
+        }
+
+        lines.push("");
+        lines.push(
+          theme.fg(
+            "muted",
+            `Selected: ${selectedSet.size} • ↑↓ navigate • space toggle • a select all • enter confirm • esc cancel`,
+          ),
+        );
+        return lines;
+      },
+      invalidate() {
+        selectList.invalidate();
+      },
+      handleInput(data: string) {
+        if (matchesKey(data, Key.enter)) {
+          const results = Array.from(selectedSet).map((i) => selectableItems[i].candidate);
+          done(results);
+          return;
+        }
+        if (matchesKey(data, Key.escape)) {
+          done([]);
+          return;
+        }
+        if (matchesKey(data, Key.space)) {
+          if (selectedSet.has(cursorPos)) {
+            selectedSet.delete(cursorPos);
+          } else {
+            selectedSet.add(cursorPos);
+          }
+          updateListLabel(cursorPos);
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, "a")) {
+          if (selectedSet.size === selectableItems.length) {
+            selectedSet.clear();
+          } else {
+            for (let i = 0; i < selectableItems.length; i++) selectedSet.add(i);
+          }
+          updateAllListLabels();
+          tui.requestRender();
+          return;
+        }
+
+        const previousCursorPos = cursorPos;
+        selectList.handleInput(data);
+        if (cursorPos !== previousCursorPos) tui.requestRender();
+      },
+    };
+  });
+
+  return result ?? [];
+}

package/types.ts

@@ -0,0 +1,12 @@
+export type Category = "reuse" | "quality" | "efficiency";
+export type Risk = "safe" | "confirm" | "review";
+export type Action = "delete" | "inline" | "refactor" | "parallelize";
+
+export type SimplifyResult = {
+  category: Category;
+  file: string;
+  lines: string;
+  reason: string;
+  risk: Risk;
+  action: Action;
+};

package/workflow.ts

@@ -0,0 +1,394 @@
+import {
+  defineTool,
+  DynamicBorder,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { Container, SelectList, Text, type SelectItem } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+import { SIMPLIFY_PROMPT } from "./prompt.js";
+import { showCandidateSelector } from "./selector.js";
+import type { SimplifyResult } from "./types.js";
+
+const categorySchema = Type.Union([
+  Type.Literal("reuse"),
+  Type.Literal("quality"),
+  Type.Literal("efficiency"),
+]);
+const riskSchema = Type.Union([
+  Type.Literal("safe"),
+  Type.Literal("confirm"),
+  Type.Literal("review"),
+]);
+const actionSchema = Type.Union([
+  Type.Literal("delete"),
+  Type.Literal("inline"),
+  Type.Literal("refactor"),
+  Type.Literal("parallelize"),
+]);
+
+type SimplifyTarget = { type: "uncommitted" } | { type: "folder"; paths: string[] };
+type ParsedArgs = {
+  target: SimplifyTarget | null;
+  additionalFocus?: string;
+  error?: string;
+};
+
+const SIMPLIFY_PRESETS = [
+  { value: "uncommitted", label: "Simplify uncommitted changes", description: "" },
+  { value: "folder", label: "Simplify a folder (or more)", description: "(snapshot, not diff)" },
+] as const;
+
+type SimplifyPresetValue = (typeof SIMPLIFY_PRESETS)[number]["value"];
+
+function parseSimplifyPaths(value: string): string[] {
+  return value
+    .split(/\s+/)
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+}
+
+function parseArgs(args: string): ParsedArgs {
+  const trimmed = args.trim();
+  if (!trimmed) return { target: null };
+
+  const [subcommand, ...rest] = trimmed.split(/\s+/);
+  if (subcommand?.toLowerCase() !== "folder") {
+    return { target: { type: "uncommitted" }, additionalFocus: trimmed };
+  }
+
+  const paths = parseSimplifyPaths(rest.join(" "));
+  if (paths.length === 0)
+    return { target: null, error: "Usage: /simplify folder <path> [path...]" };
+  return { target: { type: "folder", paths } };
+}
+
+async function hasUncommittedChanges(pi: ExtensionAPI): Promise<boolean> {
+  const { stdout, code } = await pi.exec("git", ["status", "--porcelain"]);
+  return code === 0 && stdout.trim().length > 0;
+}
+
+function buildSimplifyPrompt(target: SimplifyTarget, additionalFocus?: string): string {
+  let fullPrompt = SIMPLIFY_PROMPT;
+
+  if (target.type === "folder") {
+    fullPrompt += `\n\n## Scope Override: Folder Snapshot\n\nReview only the code in these repository-relative paths: ${target.paths.join(", ")}\n\nThis is a snapshot review, not a git diff review. Read files directly under these paths instead of relying on \`git diff\`. Only return candidates whose \`file\` is inside one of these paths.`;
+  }
+
+  if (additionalFocus?.trim()) fullPrompt += `\n\n## Additional Focus\n\n${additionalFocus.trim()}`;
+  return fullPrompt;
+}
+
+function registerSimplifyCandidatesTool(
+  pi: ExtensionAPI,
+  state: {
+    getResolver: () => ((candidates: SimplifyResult[]) => void) | null;
+    clearResolver: () => void;
+    setLatestCandidates: (candidates: SimplifyResult[]) => void;
+  },
+) {
+  const parameters = Type.Object({
+    candidates: Type.Array(
+      Type.Object({
+        category: categorySchema,
+        risk: riskSchema,
+        file: Type.String({
+          description: "Repository-relative path",
+          minLength: 1,
+          pattern: "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$)).+$",
+        }),
+        lines: Type.String({ description: "Line number or range, or empty string if unknown" }),
+        reason: Type.String({ description: "Concrete fix in one sentence" }),
+        action: actionSchema,
+      }),
+    ),
+  });
+
+  pi.registerTool(
+    defineTool({
+      name: "simplify_candidates",
+      label: "Simplify Candidates",
+      description:
+        "Return the complete candidate list for /simplify. Use as the final action after analyzing changed code.",
+      promptSnippet: "Return structured cleanup candidates for /simplify as a terminating result",
+      promptGuidelines: [
+        "Use simplify_candidates exactly once as the final action when the /simplify command asks for cleanup candidates.",
+      ],
+      parameters,
+      async execute(_toolCallId, params) {
+        const candidates: SimplifyResult[] = params.candidates;
+        const resolve = state.getResolver();
+        if (!resolve) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "Ignored simplify candidates because no /simplify analysis is pending.",
+              },
+            ],
+            details: {
+              ignored: true,
+              candidates: [],
+              byRisk: { safe: 0, confirm: 0, review: 0 },
+            },
+            terminate: true,
+          };
+        }
+
+        state.setLatestCandidates(candidates);
+        state.clearResolver();
+        resolve(candidates);
+
+        const byRisk = {
+          safe: candidates.filter((c) => c.risk === "safe").length,
+          confirm: candidates.filter((c) => c.risk === "confirm").length,
+          review: candidates.filter((c) => c.risk === "review").length,
+        };
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Captured ${candidates.length} simplify candidates (${byRisk.safe} safe, ${byRisk.confirm} confirm, ${byRisk.review} review).`,
+            },
+          ],
+          details: { ignored: false, candidates, byRisk },
+          terminate: true,
+        };
+      },
+    }),
+  );
+}
+
+async function showFolderInput(ctx: ExtensionCommandContext): Promise<SimplifyTarget | null> {
+  const result = await ctx.ui.editor(
+    "Enter folders/files to simplify (space-separated or one per line):",
+    ".",
+  );
+
+  if (!result?.trim()) return null;
+  const paths = parseSimplifyPaths(result);
+  if (paths.length === 0) return null;
+
+  return { type: "folder", paths };
+}
+
+async function showSimplifyTargetSelector(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<SimplifyTarget | null> {
+  const presetItems: SelectItem[] = SIMPLIFY_PRESETS.map((preset) => ({
+    value: preset.value,
+    label: preset.label,
+    description: preset.description,
+  }));
+  const smartDefault = (await hasUncommittedChanges(pi)) ? "uncommitted" : "folder";
+  const smartDefaultIndex = presetItems.findIndex((item) => item.value === smartDefault);
+
+  while (true) {
+    const result = await ctx.ui.custom<SimplifyPresetValue | null>((tui, theme, _kb, done) => {
+      const container = new Container();
+      container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+      container.addChild(new Text(theme.fg("accent", theme.bold("Select a simplify preset"))));
+
+      const selectList = new SelectList(presetItems, Math.min(presetItems.length, 10), {
+        selectedPrefix: (text) => theme.fg("accent", text),
+        selectedText: (text) => theme.fg("accent", text),
+        description: (text) => theme.fg("muted", text),
+        scrollInfo: (text) => theme.fg("dim", text),
+        noMatch: (text) => theme.fg("warning", text),
+      });
+
+      if (smartDefaultIndex >= 0) selectList.setSelectedIndex(smartDefaultIndex);
+      selectList.onSelect = (item) => done(item.value as SimplifyPresetValue);
+      selectList.onCancel = () => done(null);
+
+      container.addChild(selectList);
+      container.addChild(new Text(theme.fg("dim", "Press enter to confirm or esc to cancel")));
+      container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+
+      return {
+        render(width: number) {
+          return container.render(width);
+        },
+        invalidate() {
+          container.invalidate();
+        },
+        handleInput(data: string) {
+          selectList.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    });
+
+    if (!result) return null;
+    if (result === "uncommitted") return { type: "uncommitted" };
+
+    const target = await showFolderInput(ctx);
+    if (target) return target;
+  }
+}
+
+async function applyFindings(
+  ctx: ExtensionCommandContext,
+  selected: SimplifyResult[],
+  pi: ExtensionAPI,
+) {
+  if (selected.length === 0) {
+    ctx.ui.notify("No findings selected to apply", "info");
+    return;
+  }
+
+  const safeItems = selected.filter((c) => c.risk === "safe");
+  const confirmItems = selected.filter((c) => c.risk === "confirm");
+
+  const cleanupPrompt = `# Apply Review Findings
+
+Apply the following findings. Each item includes a bracketed action (e.g. \`[delete]\`, \`[refactor]\`, \`[parallelize]\`, \`[inline]\`) — follow that action, not a blanket delete.
+
+${selected.map((c) => `- ${c.file} (${c.lines || "?"}): ${c.reason} [${c.action}]`).join("\n")}
+
+For each item:
+1. Read the file to find the exact location
+2. Apply only the specified change (not surrounding code unless instructed)
+3. For refactor/inline/parallelize: preserve behavior; if the change has visible side effects, stop and report
+4. If the change affects other code, stop and report the issue
+
+After applying all changes:
+- Run \`npm test\` or equivalent; if there are no tests, verify the files parse/type-check
+- Report what changed, test results, and any items skipped with reasons`;
+
+  ctx.ui.notify(
+    `Applying ${selected.length} findings (${safeItems.length} safe, ${confirmItems.length} confirmed)`,
+    "info",
+  );
+
+  pi.sendUserMessage(cleanupPrompt);
+}
+
+export function registerSimplifyWorkflow(pi: ExtensionAPI) {
+  let resolvePendingTurnStart: (() => void) | null = null;
+  let resolvePendingCandidatesTool: ((candidates: SimplifyResult[]) => void) | null = null;
+  let latestToolCandidates: SimplifyResult[] | null = null;
+
+  pi.on("turn_start", () => {
+    if (!resolvePendingTurnStart) return;
+    const resolve = resolvePendingTurnStart;
+    resolvePendingTurnStart = null;
+    resolve();
+  });
+
+  registerSimplifyCandidatesTool(pi, {
+    getResolver: () => resolvePendingCandidatesTool,
+    clearResolver: () => {
+      resolvePendingCandidatesTool = null;
+    },
+    setLatestCandidates: (candidates) => {
+      latestToolCandidates = candidates;
+    },
+  });
+
+  pi.registerCommand("simplify", {
+    description:
+      "Review changed code or folders for reuse, quality, and efficiency, then apply fixes",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Simplify requires interactive mode", "error");
+        return;
+      }
+
+      if (!ctx.isIdle()) {
+        ctx.ui.notify(
+          "Cannot run simplify while agent is busy. Wait for current task to complete.",
+          "warning",
+        );
+        return;
+      }
+
+      const { code } = await pi.exec("git", ["rev-parse", "--git-dir"]);
+      if (code !== 0) {
+        ctx.ui.notify("Not a git repository", "error");
+        return;
+      }
+
+      const parsed = parseArgs(args);
+      if (parsed.error) {
+        ctx.ui.notify(parsed.error, "error");
+        return;
+      }
+
+      let target = parsed.target;
+      if (!target) target = await showSimplifyTargetSelector(ctx, pi);
+      if (!target) {
+        ctx.ui.notify("Simplify cancelled", "info");
+        return;
+      }
+
+      if (target.type === "uncommitted" && !(await hasUncommittedChanges(pi))) {
+        ctx.ui.notify("No git changes found. Choose folder mode to simplify a snapshot.", "info");
+        return;
+      }
+
+      const targetHint =
+        target.type === "folder" ? `folders: ${target.paths.join(", ")}` : "uncommitted changes";
+      ctx.ui.notify(`Analyzing ${targetHint} for review findings...`, "info");
+
+      const fullPrompt = buildSimplifyPrompt(target, parsed.additionalFocus);
+
+      latestToolCandidates = null;
+      const turnStarted = new Promise<void>((r) => {
+        resolvePendingTurnStart = r;
+      });
+      const toolResult = new Promise<SimplifyResult[]>((r) => {
+        resolvePendingCandidatesTool = r;
+      });
+
+      pi.sendUserMessage(fullPrompt);
+
+      const started = await Promise.race<boolean>([
+        turnStarted.then(() => true),
+        new Promise<boolean>((r) => setTimeout(() => r(false), 10000)),
+      ]);
+      if (!started) {
+        resolvePendingTurnStart = null;
+        resolvePendingCandidatesTool = null;
+        ctx.ui.notify("Analysis did not start within 10 seconds. Please try again.", "warning");
+        return;
+      }
+
+      await ctx.waitForIdle();
+
+      const candidates =
+        latestToolCandidates ??
+        (await Promise.race<SimplifyResult[] | null>([
+          toolResult,
+          new Promise<null>((r) => setTimeout(() => r(null), 100)),
+        ]));
+      resolvePendingCandidatesTool = null;
+
+      if (candidates === null) {
+        ctx.ui.notify(
+          "Could not read review findings — the model did not call simplify_candidates.",
+          "warning",
+        );
+        return;
+      }
+
+      if (candidates.length === 0) {
+        ctx.ui.notify("No review findings found!", "info");
+        return;
+      }
+
+      ctx.ui.notify(`Found ${candidates.length} findings. Select findings to apply...`, "info");
+
+      const selected = await showCandidateSelector(ctx, candidates);
+      if (!selected || selected.length === 0) {
+        ctx.ui.notify("Apply findings cancelled", "info");
+        return;
+      }
+
+      await applyFindings(ctx, selected, pi);
+    },
+  });
+}