pi-review-loop 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nico Bailon
+
+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,332 @@
+<p>
+  <img src="review-loop.png" alt="pi-review-loop" width="1100">
+</p>
+
+# Pi Review Loop
+
+Automated code review loop for pi. Repeatedly prompts the agent to review its own work until it confirms no issues remain.
+
+```
+> implement the plan
+
+[agent implements...]
+
+Review mode (1/7)  ← status appears in footer
+
+[agent reviews, finds bug, fixes it]
+
+Review mode (2/7)
+
+[agent reviews again]
+
+"No issues found."
+
+Review mode ended: no issues found  ← auto-exits
+```
+
+## Why
+
+Agents make mistakes. They miss edge cases, introduce typos, forget error handling. Asking them to review their own code catches a surprising number of issues, but you have to remember to ask, and then ask again if they found something.
+
+Reviewer Loop automates this:
+
+**Auto-Trigger** - Detects phrases like "implement the plan" or the `/double-check` template. No need to manually activate.
+
+**Persistent Loop** - After each response, sends a review prompt. If the agent found and fixed issues, it loops again. Only exits when the agent genuinely finds nothing.
+
+**Smart Exit Detection** - Won't be fooled by "Fixed 3 issues. No further issues found." Detects when issues were fixed and keeps looping.
+
+**Fully Configurable** - Every pattern is customizable. Change what triggers the loop, what exits it, and what prompt gets sent. Extend the defaults or replace them entirely.
+
+## Typical Workflow
+
+The loop shines in two scenarios:
+
+**Before implementing** — You've got a plan doc and want to sanity-check it against the actual codebase. Run `/double-check-plan` and let the agent compare the plan to what exists. It'll catch things like outdated assumptions, conflicting patterns, or unnecessary complexity. The funny thing is, it rarely finds everything on the first pass. Second pass catches different issues. Third pass, more still. That's the whole point of the loop.
+
+**After implementing** — You just finished building a feature and want to catch bugs before calling it done. Run `/double-check` and the agent reviews its own work with fresh eyes. Typos, missed edge cases, forgotten error handling — it finds stuff you'd miss staring at the same code. Again, multiple passes tend to surface different issues each time.
+
+The pattern is the same: keep reviewing until there's genuinely nothing left to find. The loop handles the "ask again" part automatically. You'll see `Review mode (2/7)` in the footer so you know it's working and how many passes it's done.
+
+## Install
+
+**npm** (recommended):
+
+```bash
+npm install -g pi-review-loop
+```
+
+The extension is automatically copied to `~/.pi/agent/extensions/pi-review-loop/`.
+
+**Or clone directly:**
+
+```bash
+git clone https://github.com/nicobailon/pi-review-loop ~/.pi/agent/extensions/pi-review-loop
+```
+
+Restart pi to load the extension. On activation, you'll see status in the footer:
+
+```
+Review mode (2/7)
+```
+
+## Prompt Templates
+
+The package includes two prompt templates that are automatically installed to `~/.pi/agent/prompts/` (if they don't already exist):
+
+| Template | Command | Description |
+|----------|---------|-------------|
+| `double-check.md` | `/double-check` | Review code with fresh eyes, fix any issues found |
+| `double-check-plan.md` | `/double-check-plan` | Review implementation plan against codebase |
+
+These prompts are designed to work with the review loop:
+- They include the "fresh eyes" phrase that auto-triggers the loop
+- They instruct the agent to respond with "No issues found." when done (triggering exit)
+- They tell the agent to end with "Fixed [N] issue(s). Ready for another review." when issues are fixed (continuing the loop)
+
+**Manual installation** (if cloning instead of npm):
+
+```bash
+cp ~/.pi/agent/extensions/pi-review-loop/prompts/*.md ~/.pi/agent/prompts/
+```
+
+## Quick Start
+
+### Automatic Activation
+
+Just use trigger phrases naturally:
+
+```
+> implement the plan
+> implement the spec
+> let's implement this plan
+```
+
+Or use the `/double-check` prompt template.
+
+### Manual Activation
+
+```
+/review-start
+```
+
+Activates review mode and immediately sends the review prompt.
+
+### Check Status
+
+```
+/review-status
+```
+
+Shows whether review mode is active and current iteration.
+
+### Exit Early
+
+```
+/review-exit
+```
+
+Or just type something else. Any non-trigger input exits review mode.
+
+### Adjust Iterations
+
+```
+/review-max 5
+```
+
+Changes max iterations for current session.
+
+## Configuration
+
+Configure in `~/.pi/agent/settings.json`. Works out of the box, but everything is customizable:
+
+```json
+{
+  "reviewerLoop": {
+    "maxIterations": 7,
+    "reviewPrompt": "template:double-check",
+    "triggerPatterns": {
+      "mode": "extend",
+      "patterns": ["execute the plan"]
+    },
+    "exitPatterns": {
+      "mode": "extend",
+      "patterns": ["ship it", "ready to merge"]
+    },
+    "issuesFixedPatterns": {
+      "mode": "extend",
+      "patterns": ["addressed the following"]
+    }
+  }
+}
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `maxIterations` | Max review prompts before auto-exit (default: 7) |
+| `reviewPrompt` | The prompt to send each iteration |
+| `triggerPatterns` | What activates review mode |
+| `exitPatterns` | What indicates "review complete" |
+| `issuesFixedPatterns` | What indicates issues were fixed (prevents false exits) |
+
+### Review Prompt Sources
+
+Three formats for `reviewPrompt`:
+
+| Format | Example | Description |
+|--------|---------|-------------|
+| Template | `"template:double-check"` | Loads `~/.pi/agent/prompts/double-check.md` |
+| File | `"~/prompts/review.md"` | Loads from any file path |
+| Inline | `"Review the code carefully..."` | Uses text directly |
+
+Templates and files reload on each use. Edit them and changes take effect immediately.
+
+### Pattern Configuration
+
+Each pattern setting accepts:
+
+```json
+{
+  "mode": "extend",
+  "patterns": ["simple string", "/regex\\s+pattern/i"]
+}
+```
+
+**Modes:**
+- `"extend"` (default, recommended) - Add your patterns to the built-in defaults
+- `"replace"` - Use only your patterns, discard defaults entirely
+
+**Pattern formats:**
+- Simple string → auto-escaped, case-insensitive literal match
+- `/pattern/flags` → full regex with custom flags
+
+**Why extend mode is recommended:** The built-in defaults use sophisticated regex patterns to handle edge cases (e.g., distinguishing "No issues found" from "Issues found and fixed"). If you use replace mode, you take full responsibility for handling these nuances. Extend mode lets you add simple patterns like `"ship it"` while the defaults handle the tricky stuff.
+
+## Default Patterns
+
+These are the built-ins (all customizable):
+
+**Triggers:**
+- "implement plan/spec", "implement the plan/spec"
+- "start implementing", "let's implement", "go ahead and implement"
+- `/double-check` template content
+
+**Exit phrases:**
+- "no issues found", "no bugs found"
+- "looks good", "all good" (on own line)
+
+**Issues-fixed indicators:**
+- "fixed the following", "issues fixed", "bugs fixed"
+- "Issues:", "Bugs:", "Changes:" (headers)
+- "ready for another review"
+
+## Exit Conditions
+
+The loop exits when:
+
+1. **Exit phrase without fixes** - Agent says "no issues" and didn't fix anything
+2. **Max iterations** - Safety limit reached (default: 7)
+3. **User interrupts** - You type something that isn't a trigger
+4. **Manual exit** - `/review-exit` command
+5. **Abort** - Press ESC or agent response is empty
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/review-start` | Activate and send review prompt immediately |
+| `/review-exit` | Exit review mode |
+| `/review-max <n>` | Set max iterations (session only) |
+| `/review-status` | Show current state |
+
+## Tool API
+
+The `review_loop` tool lets the agent programmatically control review mode:
+
+```typescript
+// Check status (default)
+review_loop({})
+
+// Start review mode
+review_loop({ start: true })
+
+// Start with custom max iterations
+review_loop({ start: true, maxIterations: 5 })
+
+// Stop review mode
+review_loop({ stop: true })
+
+// Just update max iterations
+review_loop({ maxIterations: 10 })
+```
+
+**Returns:**
+```json
+{
+  "active": true,
+  "currentIteration": 2,
+  "maxIterations": 7,
+  "message": "Review mode active: iteration 2/7"
+}
+```
+
+**Mode priority:** `start` > `stop` > status (default)
+
+## How It Works
+
+```
+input event
+    ↓
+matches trigger? → enter review mode
+    ↓
+agent responds
+    ↓
+agent_end event
+    ↓
+matches exit + no fixes? → exit review mode
+    ↓
+iteration < max? → send review prompt → loop
+    ↓
+otherwise → exit (max reached)
+```
+
+**Events used:**
+- `session_start` - Reload settings
+- `input` - Detect triggers, handle interrupts
+- `before_agent_start` - Check expanded prompts for triggers
+- `agent_end` - Analyze response, decide to loop or exit
+
+## Limitations
+
+- **User templates only** - `template:name` loads from `~/.pi/agent/prompts/`, not project templates
+- **Session-scoped /review-max** - Doesn't persist across sessions
+- **Pattern failures are silent** - Invalid regex patterns are skipped without error
+
+## File Structure
+
+```
+pi-review-loop/
+├── index.ts           # Extension entry, event handlers, commands
+├── settings.ts        # Configuration loading, pattern parsing, defaults
+├── scripts/
+│   ├── install.js     # npm postinstall - copies extension + prompts
+│   └── uninstall.js   # npm preuninstall - removes extension
+├── prompts/
+│   ├── double-check.md       # Review code template
+│   └── double-check-plan.md  # Review plan template
+├── package.json
+├── review-loop.png    # Banner image
+├── README.md
+├── CHANGELOG.md
+└── LICENSE
+```
+
+## Credits
+
+Inspired by and built on ideas from:
+
+- **[Ralph Wiggum Loop](https://ghuntley.com/ralph/)** by [@GeoffreyHuntley](https://x.com/GeoffreyHuntley) - Loosely based on the "Ralph" loop
+- **["Fresh eyes" review prompt](https://x.com/doodlestein/status/1956228999945806049)** by [@doodlestein](https://x.com/doodlestein)
+- **[pi](https://github.com/badlogic/pi-mono/)** by [@badlogicgames](https://x.com/badlogicgames) — The agent framework powering all of this

package/index.ts

@@ -0,0 +1,280 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { loadSettings, getReviewPrompt, type ReviewerLoopSettings } from "./settings.js";
+
+export default function (pi: ExtensionAPI) {
+  let settings: ReviewerLoopSettings = loadSettings();
+  let reviewModeActive = false;
+  let currentIteration = 0;
+
+  function updateStatus(ctx: ExtensionContext) {
+    if (reviewModeActive) {
+      ctx.ui.setStatus(
+        "review-loop",
+        `Review mode (${currentIteration}/${settings.maxIterations})`
+      );
+    } else {
+      ctx.ui.setStatus("review-loop", undefined);
+    }
+  }
+
+  function exitReviewMode(ctx: ExtensionContext, reason: string) {
+    reviewModeActive = false;
+    currentIteration = 0;
+    updateStatus(ctx);
+    ctx.ui.notify(`Review mode ended: ${reason}`, "info");
+  }
+
+  function enterReviewMode(ctx: ExtensionContext) {
+    reviewModeActive = true;
+    currentIteration = 0;
+    updateStatus(ctx);
+    ctx.ui.notify("Review mode activated", "info");
+  }
+
+  pi.on("session_start", async () => {
+    settings = loadSettings();
+  });
+
+  pi.on("input", async (event, ctx) => {
+    if (!ctx.hasUI) return { action: "continue" as const };
+
+    const isTrigger = settings.triggerPatterns.some((p) => p.test(event.text));
+
+    if (reviewModeActive && event.source === "interactive" && !isTrigger) {
+      exitReviewMode(ctx, "user interrupted");
+      return { action: "continue" as const };
+    }
+
+    if (isTrigger && !reviewModeActive) {
+      enterReviewMode(ctx);
+    }
+
+    return { action: "continue" as const };
+  });
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    if (!ctx.hasUI) return;
+    if (reviewModeActive) return;
+
+    const isTrigger = settings.triggerPatterns.some((p) => p.test(event.prompt));
+    if (isTrigger) {
+      enterReviewMode(ctx);
+    }
+  });
+
+  pi.on("agent_end", async (event, ctx) => {
+    if (!ctx.hasUI) return;
+    if (!reviewModeActive) return;
+
+    const assistantMessages = event.messages.filter((m) => m.role === "assistant");
+    const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+
+    if (!lastAssistantMessage) {
+      exitReviewMode(ctx, "aborted");
+      return;
+    }
+
+    const textContent = lastAssistantMessage.content
+      .filter((c): c is { type: "text"; text: string } => c.type === "text")
+      .map((c) => c.text)
+      .join("\n");
+
+    if (!textContent.trim()) {
+      exitReviewMode(ctx, "aborted");
+      return;
+    }
+
+    const hasExitPhrase = settings.exitPatterns.some((p) => p.test(textContent));
+    const hasIssuesFixed = settings.issuesFixedPatterns.some((p) =>
+      p.test(textContent)
+    );
+
+    if (hasExitPhrase && !hasIssuesFixed) {
+      exitReviewMode(ctx, "no issues found");
+      return;
+    }
+
+    currentIteration++;
+    if (currentIteration > settings.maxIterations) {
+      exitReviewMode(ctx, `max iterations (${settings.maxIterations}) reached`);
+      return;
+    }
+
+    updateStatus(ctx);
+    pi.sendUserMessage(getReviewPrompt(settings.reviewPromptConfig), {
+      deliverAs: "followUp",
+    });
+  });
+
+  pi.registerCommand("review-start", {
+    description: "Activate review loop and send review prompt immediately",
+    handler: async (_args, ctx) => {
+      if (reviewModeActive) {
+        ctx.ui.notify("Review mode is already active", "info");
+      } else {
+        enterReviewMode(ctx);
+        pi.sendUserMessage(getReviewPrompt(settings.reviewPromptConfig));
+      }
+    },
+  });
+
+  pi.registerCommand("review-max", {
+    description: "Set max review iterations (default: 7)",
+    handler: async (args, ctx) => {
+      const num = parseInt(args, 10);
+      if (isNaN(num) || num < 1) {
+        ctx.ui.notify("Usage: /review-max <number>", "error");
+        return;
+      }
+      settings.maxIterations = num;
+      ctx.ui.notify(`Max review iterations set to ${settings.maxIterations}`, "info");
+    },
+  });
+
+  pi.registerCommand("review-exit", {
+    description: "Exit review mode manually",
+    handler: async (_args, ctx) => {
+      if (reviewModeActive) {
+        exitReviewMode(ctx, "manual exit");
+      } else {
+        ctx.ui.notify("Review mode is not active", "info");
+      }
+    },
+  });
+
+  pi.registerCommand("review-status", {
+    description: "Show review mode status",
+    handler: async (_args, ctx) => {
+      if (reviewModeActive) {
+        ctx.ui.notify(
+          `Review mode active: iteration ${currentIteration}/${settings.maxIterations}`,
+          "info"
+        );
+      } else {
+        ctx.ui.notify(
+          `Review mode inactive (max: ${settings.maxIterations})`,
+          "info"
+        );
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "review_loop",
+    description:
+      "Control the automated code review loop. Start/stop review mode or check status. When started, the loop repeatedly prompts for code review until 'No issues found' or max iterations reached.",
+    parameters: Type.Object({
+      start: Type.Optional(
+        Type.Boolean({
+          description: "Start review mode and send the review prompt",
+        })
+      ),
+      stop: Type.Optional(
+        Type.Boolean({
+          description: "Stop review mode",
+        })
+      ),
+      maxIterations: Type.Optional(
+        Type.Number({
+          description: "Set max iterations (can be combined with start)",
+          minimum: 1,
+        })
+      ),
+    }),
+
+    async execute(_toolCallId, params, _onUpdate, ctx) {
+      // Update maxIterations if provided
+      if (typeof params.maxIterations === "number" && params.maxIterations >= 1) {
+        settings.maxIterations = params.maxIterations;
+      }
+
+      // Mode: start > stop > status
+      if (params.start) {
+        if (reviewModeActive) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  active: true,
+                  currentIteration,
+                  maxIterations: settings.maxIterations,
+                  message: "Review mode is already active",
+                }),
+              },
+            ],
+          };
+        }
+
+        enterReviewMode(ctx);
+        pi.sendUserMessage(getReviewPrompt(settings.reviewPromptConfig));
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                active: true,
+                currentIteration,
+                maxIterations: settings.maxIterations,
+                message: "Review mode started. Review prompt sent.",
+              }),
+            },
+          ],
+        };
+      }
+
+      if (params.stop) {
+        if (!reviewModeActive) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  active: false,
+                  currentIteration: 0,
+                  maxIterations: settings.maxIterations,
+                  message: "Review mode is not active",
+                }),
+              },
+            ],
+          };
+        }
+
+        exitReviewMode(ctx, "stopped by agent");
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                active: false,
+                currentIteration: 0,
+                maxIterations: settings.maxIterations,
+                message: "Review mode stopped",
+              }),
+            },
+          ],
+        };
+      }
+
+      // Default: status
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              active: reviewModeActive,
+              currentIteration,
+              maxIterations: settings.maxIterations,
+              message: reviewModeActive
+                ? `Review mode active: iteration ${currentIteration}/${settings.maxIterations}`
+                : "Review mode inactive",
+            }),
+          },
+        ],
+      };
+    },
+  });
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "pi-review-loop",
+  "version": "0.1.1",
+  "description": "Automated code review loop extension for pi coding agent",
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "preuninstall": "node scripts/uninstall.js"
+  },
+  "files": [
+    "index.ts",
+    "settings.ts",
+    "review-loop.png",
+    "scripts/",
+    "prompts/"
+  ],
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "code-review",
+    "automation",
+    "ralph-wiggum-loop"
+  ],
+  "author": "Nico Bailon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nicobailon/pi-review-loop.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nicobailon/pi-review-loop/issues"
+  },
+  "homepage": "https://github.com/nicobailon/pi-review-loop#readme"
+}

package/prompts/double-check-plan.md

@@ -0,0 +1,10 @@
+---
+description: Double check / critique implementation plan with fresh eyes
+---
+Great, now I want you to carefully read over the plan/spec and compare against the codebase with "fresh eyes," looking super carefully for any obvious bugs, errors, problems, issues, confusion, etc. Also double check that the patterns and coding styles match existing codebase conventions and preferences. Consider whether there is any unnecessary complexity or duplication, or if the changes can be more minimal without changing scope of requirements and without causing regressions or increasing the risk of bugs. Also keep in mind that this is not an MVP - so don't skip anything. If any issues are found, proceed to fix them without being asked to do so.
+
+**Response format:**
+- If you find ANY issues: fix them, then list what you fixed. Do NOT say "no issues found" - instead end with "Fixed [N] issue(s). Ready for another review."
+- If you find ZERO issues: respond with exactly "No issues found."
+
+$@

package/prompts/double-check.md

@@ -0,0 +1,10 @@
+---
+description: Double check / review implementation with fresh eyes
+---
+Great, now I want you to carefully read over all of the new code you just wrote and other existing code with "fresh eyes," looking super carefully for any obvious bugs, errors, problems, issues, confusion, etc. Also, if you notice any pre-existing issues/bugs those should be addressed.
+
+**Response format:**
+- If you find ANY issues: fix them, then list what you fixed. Do NOT say "no issues found" - instead end with "Fixed [N] issue(s). Ready for another review."
+- If you find ZERO issues: respond with exactly "No issues found."
+
+$@

package/scripts/install.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const EXTENSION_NAME = "pi-review-loop";
+const TARGET_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", EXTENSION_NAME);
+const PROMPTS_DIR = path.join(os.homedir(), ".pi", "agent", "prompts");
+const SOURCE_DIR = path.dirname(__dirname);
+const FILES = ["index.ts", "settings.ts", "review-loop.png"];
+const PROMPTS = ["double-check.md", "double-check-plan.md"];
+
+try {
+  // Install extension files
+  fs.mkdirSync(TARGET_DIR, { recursive: true });
+
+  for (const file of FILES) {
+    const src = path.join(SOURCE_DIR, file);
+    const dest = path.join(TARGET_DIR, file);
+
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, dest);
+    }
+  }
+
+  // Install prompt templates (skip if already exist)
+  fs.mkdirSync(PROMPTS_DIR, { recursive: true });
+  const installedPrompts = [];
+
+  for (const file of PROMPTS) {
+    const src = path.join(SOURCE_DIR, "prompts", file);
+    const dest = path.join(PROMPTS_DIR, file);
+
+    if (fs.existsSync(src) && !fs.existsSync(dest)) {
+      fs.copyFileSync(src, dest);
+      installedPrompts.push(file);
+    }
+  }
+
+  console.log("");
+  console.log("✓ pi-review-loop installed to ~/.pi/agent/extensions/pi-review-loop/");
+  if (installedPrompts.length > 0) {
+    console.log(`✓ Prompt templates installed: ${installedPrompts.join(", ")}`);
+  }
+  console.log("  Restart pi to load the extension.");
+  console.log("");
+} catch (err) {
+  console.error("Failed to install pi-review-loop:", err.message);
+  process.exit(1);
+}

package/scripts/uninstall.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const EXTENSION_NAME = "pi-review-loop";
+const TARGET_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", EXTENSION_NAME);
+
+try {
+  if (fs.existsSync(TARGET_DIR)) {
+    fs.rmSync(TARGET_DIR, { recursive: true });
+    console.log("");
+    console.log("✓ pi-review-loop removed from ~/.pi/agent/extensions/pi-review-loop/");
+    console.log("");
+  }
+} catch (err) {
+  console.error("Failed to uninstall pi-review-loop:", err.message);
+}

package/settings.ts

@@ -0,0 +1,211 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export const SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
+
+export const DEFAULT_MAX_ITERATIONS = 7;
+
+export const DEFAULT_REVIEW_PROMPT = `Great, now I want you to carefully read over all of the new code you just wrote and other existing code you just modified with "fresh eyes," looking super carefully for any obvious bugs, errors, problems, issues, confusion, etc. If any issues are found, proceed to fix them without being asked to do so.
+
+**Response format:**
+- If you find ANY issues: fix them, then list what you fixed. Do NOT say "no issues found" - instead end with "Fixed [N] issue(s). Ready for another review."
+- If you find ZERO issues: respond with exactly "No issues found."`;
+
+export const DEFAULT_TRIGGER_PATTERNS: RegExp[] = [
+  /\bimplement\s+(the\s+)?plan\b/i,
+  /\bimplement\s+(the\s+)?spec\b/i,
+  /\bimplement\s+(this\s+)?plan\b/i,
+  /\bimplement\s+(this\s+)?spec\b/i,
+  /\bstart\s+implementing\b.*\b(plan|spec)\b/i,
+  /\bgo\s+ahead\s+and\s+implement\b.*\b(plan|spec)\b/i,
+  /\blet'?s\s+implement\b.*\b(plan|spec)\b/i,
+  /\b(plan|spec)\b.*\bstart\s+implementing\b/i,
+  /\b(plan|spec)\b.*\bgo\s+ahead\s+and\s+implement\b/i,
+  /\b(plan|spec)\b.*\blet'?s\s+implement\b/i,
+  /read over all of the new code.*fresh eyes/i,
+];
+
+export const DEFAULT_EXIT_PATTERNS: RegExp[] = [
+  /no\s+(\w+\s+)?issues\s+found/i,
+  /no\s+(\w+\s+)?bugs\s+found/i,
+  /(?:^|\n)\s*(?:looks\s+good|all\s+good)[\s.,!]*(?:$|\n)/im,
+];
+
+export const DEFAULT_ISSUES_FIXED_PATTERNS: RegExp[] = [
+  /issues?\s+(i\s+)?fixed/i,
+  /fixed\s+(the\s+)?(following|these|this|issues?|bugs?)/i,
+  /fixed\s+\d+\s+issues?/i,
+  /found\s+and\s+(fixed|corrected|resolved)/i,
+  /bugs?\s+(i\s+)?fixed/i,
+  /corrected\s+(the\s+)?(following|these|this)/i,
+  /(?<!no\s)issues?\s+(i\s+)?(found|identified|discovered)/i,
+  /(?<!no\s)problems?\s+(i\s+)?(found|identified|discovered)/i,
+  /changes?\s+(i\s+)?made/i,
+  /here'?s?\s+what\s+(i\s+)?(fixed|changed|corrected)/i,
+  /(issues|bugs|problems|changes|fixes)\s*:/i,
+  /ready\s+for\s+(another|the\s+next)\s+review/i,
+];
+
+export interface PatternConfig {
+  mode?: "extend" | "replace";
+  patterns: string[];
+}
+
+export interface ReviewPromptConfig {
+  type: "inline" | "file" | "template";
+  value: string;
+}
+
+export interface ReviewerLoopSettingsRaw {
+  maxIterations?: number;
+  reviewPrompt?: string;
+  triggerPatterns?: PatternConfig;
+  exitPatterns?: PatternConfig;
+  issuesFixedPatterns?: PatternConfig;
+}
+
+export interface ReviewerLoopSettings {
+  maxIterations: number;
+  reviewPromptConfig: ReviewPromptConfig;
+  triggerPatterns: RegExp[];
+  exitPatterns: RegExp[];
+  issuesFixedPatterns: RegExp[];
+}
+
+function parsePattern(input: unknown): RegExp | null {
+  if (typeof input !== "string") return null;
+
+  const match = input.match(/^\/(.+)\/([gimsuy]*)$/);
+  if (match) {
+    try {
+      return new RegExp(match[1], match[2]);
+    } catch {
+      return null;
+    }
+  }
+  const escaped = input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(escaped, "i");
+}
+
+function loadPatterns(
+  config: PatternConfig | undefined,
+  defaults: RegExp[]
+): RegExp[] {
+  if (!config?.patterns || !Array.isArray(config.patterns) || config.patterns.length === 0) {
+    return defaults;
+  }
+
+  const userPatterns = config.patterns
+    .map(parsePattern)
+    .filter((p): p is RegExp => p !== null);
+
+  if (config.mode === "replace") {
+    return userPatterns.length > 0 ? userPatterns : defaults;
+  }
+
+  return [...defaults, ...userPatterns];
+}
+
+function isFilePath(value: string): boolean {
+  return (
+    value.startsWith("~/") ||
+    value.startsWith("/") ||
+    value.startsWith("./") ||
+    value.endsWith(".md") ||
+    value.endsWith(".txt")
+  );
+}
+
+function parseReviewPromptConfig(value: string | undefined): ReviewPromptConfig {
+  if (!value) {
+    return { type: "inline", value: DEFAULT_REVIEW_PROMPT };
+  }
+
+  if (value.startsWith("template:")) {
+    const templateName = value.slice("template:".length).trim();
+    return { type: "template", value: templateName };
+  }
+
+  if (isFilePath(value)) {
+    return { type: "file", value };
+  }
+
+  return { type: "inline", value };
+}
+
+function stripFrontmatter(content: string): string {
+  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n)?([\s\S]*)$/);
+  return match ? match[1].trim() : content.trim();
+}
+
+function resolvePath(value: string): string {
+  if (value.startsWith("~/")) {
+    return join(homedir(), value.slice(2));
+  }
+  return value;
+}
+
+export function getReviewPrompt(config: ReviewPromptConfig): string {
+  switch (config.type) {
+    case "inline":
+      return config.value || DEFAULT_REVIEW_PROMPT;
+
+    case "file": {
+      const resolvedPath = resolvePath(config.value);
+      try {
+        const content = readFileSync(resolvedPath, "utf-8").trim();
+        return content || DEFAULT_REVIEW_PROMPT;
+      } catch {
+        return DEFAULT_REVIEW_PROMPT;
+      }
+    }
+
+    case "template": {
+      const templatePath = join(
+        homedir(),
+        ".pi",
+        "agent",
+        "prompts",
+        `${config.value}.md`
+      );
+      try {
+        if (!existsSync(templatePath)) {
+          return DEFAULT_REVIEW_PROMPT;
+        }
+        let content = readFileSync(templatePath, "utf-8");
+        content = stripFrontmatter(content);
+        content = content.replace(/\$@/g, "").trim();
+        return content || DEFAULT_REVIEW_PROMPT;
+      } catch {
+        return DEFAULT_REVIEW_PROMPT;
+      }
+    }
+  }
+}
+
+export function loadSettings(): ReviewerLoopSettings {
+  let raw: ReviewerLoopSettingsRaw = {};
+
+  try {
+    const content = readFileSync(SETTINGS_PATH, "utf-8");
+    const parsed = JSON.parse(content);
+    raw = parsed?.reviewerLoop ?? {};
+  } catch {
+    // Use all defaults
+  }
+
+  return {
+    maxIterations:
+      typeof raw.maxIterations === "number" && raw.maxIterations >= 1
+        ? raw.maxIterations
+        : DEFAULT_MAX_ITERATIONS,
+    reviewPromptConfig: parseReviewPromptConfig(raw.reviewPrompt),
+    triggerPatterns: loadPatterns(raw.triggerPatterns, DEFAULT_TRIGGER_PATTERNS),
+    exitPatterns: loadPatterns(raw.exitPatterns, DEFAULT_EXIT_PATTERNS),
+    issuesFixedPatterns: loadPatterns(
+      raw.issuesFixedPatterns,
+      DEFAULT_ISSUES_FIXED_PATTERNS
+    ),
+  };
+}