@in-the-loop-labs/pair-review 1.1.1 → 1.2.0

package/README.md

@@ -33,7 +33,7 @@ pair-review is a local web application that transforms how you review code, espe
 - **Local-First**: All data and processing happens on your machine - no cloud dependencies
 - **GitHub-Familiar UI**: Interface feels instantly familiar to GitHub users
 - **Human-in-the-Loop**: AI suggests, you decide
-- **Multiple AI Providers**: Support for Claude, Gemini, Codex, Copilot, and OpenCode. Use your existing subscription!
+- **Multiple AI Providers**: Support for Claude, Gemini, Codex, Copilot, OpenCode, and Cursor. Use your existing subscription!
 - **Progressive**: Start simple with manual review, add AI analysis when you need it
 
 ## Quick Start
@@ -141,7 +141,7 @@ Configuration is stored in `~/.pair-review/config.json`:
 ```json
 {
   "github_token": "ghp_your_token_here",
-  "port": 3000,
+  "port": 7247,
   "theme": "light",
   "default_provider": "claude",
   "default_model": "sonnet"
@@ -164,6 +164,7 @@ pair-review supports several environment variables for customizing behavior:
 | `PAIR_REVIEW_CODEX_CMD` | Custom command to invoke Codex CLI | `codex` |
 | `PAIR_REVIEW_COPILOT_CMD` | Custom command to invoke Copilot CLI | `copilot` |
 | `PAIR_REVIEW_OPENCODE_CMD` | Custom command to invoke OpenCode CLI | `opencode` |
+| `PAIR_REVIEW_CURSOR_AGENT_CMD` | Custom command to invoke Cursor Agent CLI | `agent` |
 | `PAIR_REVIEW_MODEL` | Override the AI model to use (same as `--model` flag) | Provider default |
 
 **Note:** `GITHUB_TOKEN` is the standard environment variable used by many GitHub tools (gh CLI, GitHub Actions, etc.). When set, it takes precedence over the `github_token` field in the config file.
@@ -216,6 +217,7 @@ pair-review integrates with AI providers via their CLI tools:
 - **Codex**: Uses Codex CLI
 - **GitHub Copilot**: Uses Copilot CLI
 - **OpenCode**: Uses OpenCode CLI (requires model configuration)
+- **Cursor**: Uses Cursor Agent CLI (streaming output with sandbox mode)
 
 You can select your preferred provider and model in the repository settings UI.
 
@@ -362,6 +364,157 @@ Perfect for:
 - Reviewing only the unstaged files that are still changing
 - Staging the files you've already reviewed and viewing the next round of changes
 
+## Claude Code Plugins
+
+pair-review provides two [Claude Code plugins](https://code.claude.com/docs/en/plugins) that bring AI-powered code review directly into Claude Code.
+
+### code-critic — Standalone Analysis
+
+AI-powered code review analysis that works without any server or MCP dependency. Install this plugin for three-level AI analysis and implement-review-fix loops directly in your coding agent.
+
+**Install via Marketplace:**
+
+```
+/plugin marketplace add in-the-loop-labs/pair-review
+/plugin install pair-review@code-critic
+```
+
+**Available Skills:**
+
+| Skill | Description |
+|-------|-------------|
+| `/code-critic:analyze` | Run three-level AI analysis using Task agents directly (standalone, no server needed) |
+| `/code-critic:loop` | Implement code, review with AI, fix issues, and repeat until clean |
+
+These skills work standalone. If the pair-review MCP server happens to be available (from the pair-review plugin), `code-critic:analyze` will use it for prompts and push results to the web UI — but it's entirely optional.
+
+### pair-review — App Integration
+
+Full integration with the pair-review web UI via MCP. Install this plugin to open reviews in the browser, run server-side AI analysis, and address review feedback.
+
+**Install via Marketplace:**
+
+```
+/plugin marketplace add in-the-loop-labs/pair-review
+/plugin install pair-review@pair-review
+```
+
+**Available Skills:**
+
+| Skill | Description |
+|-------|-------------|
+| `/pair-review:pr` | Open the current branch's GitHub PR in the pair-review web UI |
+| `/pair-review:local` | Open local uncommitted changes in the pair-review web UI |
+| `/pair-review:analyze` | Run AI analysis via the pair-review MCP server (results appear in web UI) |
+| `/pair-review:user-critic` | Fetch and address human review comments from pair-review |
+| `/pair-review:ai-critic` | Fetch and address AI-generated suggestions from pair-review |
+
+This plugin includes the pair-review MCP server, which starts automatically when the plugin is enabled.
+
+### Alternative: Load Plugins Locally
+
+If you prefer not to use the marketplace, load plugins directly from an npm-installed or cloned copy:
+
+```bash
+# From a local clone
+claude --plugin-dir ./path/to/pair-review/plugin-code-critic
+claude --plugin-dir ./path/to/pair-review/plugin
+
+# From a globally installed npm package
+claude --plugin-dir "$(npm root -g)/@in-the-loop-labs/pair-review/plugin-code-critic"
+claude --plugin-dir "$(npm root -g)/@in-the-loop-labs/pair-review/plugin"
+```
+
+### Team Setup
+
+To pre-configure plugins for all contributors on a repository, add this to your `.claude/settings.json`:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "pair-review": {
+      "source": {
+        "source": "github",
+        "repo": "in-the-loop-labs/pair-review"
+      }
+    }
+  },
+  "enabledPlugins": {
+    "pair-review@code-critic": true,
+    "pair-review@pair-review": true
+  }
+}
+```
+
+Team members will be prompted to install the marketplace and plugins when they trust the repository folder.
+
+## MCP Integration
+
+pair-review exposes a [Model Context Protocol (MCP)](https://modelcontextprotocol.io) interface, allowing AI coding agents to programmatically read review feedback. The MCP server is included automatically when you install the pair-review Claude Code plugin. For standalone MCP setup (without the plugin), see [Standalone MCP Setup](#standalone-mcp-setup-without-plugin) below.
+
+### Transport Modes
+
+**stdio (recommended)** — run pair-review as a stdio MCP server. The agent communicates via stdin/stdout JSON-RPC while the web UI launches on a local port for the human reviewer:
+
+```bash
+npx @in-the-loop-labs/pair-review --mcp
+```
+
+**HTTP** — the Streamable HTTP endpoint at `http://localhost:7247/mcp` (stateless mode) is available whenever the pair-review web server is running.
+
+### Available Tools
+
+| Tool | Description | Availability |
+|------|-------------|--------------|
+| `get_server_info` | Get pair-review server info including web UI URL and version | stdio only |
+| `get_analysis_prompt` | Get rendered analysis prompts for a review level and tier | stdio + HTTP |
+| `get_user_comments` | Get human-curated review comments (authored or adopted), grouped by file | stdio + HTTP |
+| `get_ai_analysis_runs` | List all AI analysis runs for a review | stdio + HTTP |
+| `get_ai_suggestions` | Get AI-generated suggestions from the latest analysis run, or from a specific run via `runId` | stdio + HTTP |
+| `start_analysis` | Start an AI analysis in the app for local or PR changes | stdio + HTTP |
+
+All review tools accept lookup parameters:
+- **Local reviews**: `path` + `headSha`
+- **PR reviews**: `repo` (e.g. `"owner/repo"`) + `prNumber`
+
+`get_ai_suggestions` also accepts an optional `runId` to target a specific analysis run (discovered via `get_ai_analysis_runs`), bypassing the need for review lookup parameters.
+
+### Standalone MCP Setup (Without Plugin)
+
+If you want just the MCP tools without the full plugin (no skills), you can add the MCP server directly to any coding agent that supports MCP (Claude Code, Cursor, Windsurf, etc.).
+
+#### Generic MCP Configuration
+
+**stdio transport (recommended)** — run pair-review as a child process. The agent communicates via stdin/stdout JSON-RPC:
+
+- **Command:** `npx @in-the-loop-labs/pair-review --mcp`
+- **Environment variables:** Set `GITHUB_TOKEN` if you want PR review support (not needed for local-only reviews). GitHub token will also be read from `~/.pair-review/config.json` if configured.
+
+**HTTP transport** — connect to a running pair-review instance:
+
+- **URL:** `http://localhost:7247/mcp` (stateless Streamable HTTP)
+- Start the server first with `npx @in-the-loop-labs/pair-review` or by opening a PR review, then point your agent at the HTTP endpoint.
+
+You can also copy the `plugin/.mcp.json` file from this package into your project for agents that support `.mcp.json` discovery.
+
+#### Claude Code Specific
+
+Add the MCP server via the Claude Code CLI:
+
+**stdio transport (recommended):**
+
+```bash
+claude mcp add pair-review -- npx @in-the-loop-labs/pair-review --mcp
+```
+
+**HTTP transport:**
+
+```bash
+claude mcp add --transport http pair-review http://localhost:7247/mcp
+```
+
+These commands update your MCP configuration in `~/.claude/settings.json` (user-level) or your project's `.claude/settings.json` (project-level).
+
 ## Development
 
 ### Prerequisites

package/bin/pair-review.js

@@ -3,25 +3,40 @@
 
 const path = require('path');
 const { spawn } = require('child_process');
-const updateNotifier = require('update-notifier');
 const pkg = require('../package.json');
 
-// Check for updates and notify user
-updateNotifier({ pkg }).notify();
+const args = process.argv.slice(2);
+const isMCP = args.includes('--mcp');
+
+// Check for updates and notify user (skip in MCP mode to avoid stdout pollution)
+if (!isMCP) {
+  const updateNotifier = require('update-notifier');
+  updateNotifier({ pkg }).notify();
+}
 
 async function main() {
   try {
-    // Get command line arguments (excluding 'node' and script path)
-    const args = process.argv.slice(2);
-    
     // Get the path to the main application file
     const mainPath = path.join(__dirname, '..', 'src', 'main.js');
-    
+
+    // In MCP mode, pipe stdin/stdout for JSON-RPC and inherit stderr for logs.
+    // In normal mode, inherit all stdio streams.
+    const stdioOption = isMCP
+      ? ['pipe', 'pipe', 'inherit']
+      : 'inherit';
+
     // Spawn the main process with arguments
     const app = spawn('node', [mainPath, ...args], {
-      stdio: 'inherit'
+      stdio: stdioOption
     });
 
+    // In MCP mode, bridge stdin/stdout between parent and child
+    if (isMCP) {
+      process.stdin.pipe(app.stdin);
+      app.stdout.pipe(process.stdout);
+      app.stdin.on('error', () => {}); // ignore EPIPE if child exits
+    }
+
     app.on('error', (error) => {
       console.error('Failed to start pair-review:', error.message);
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Your AI-powered code review partner - Close the feedback loop with AI coding agents",
   "main": "src/server.js",
   "bin": {
@@ -11,6 +11,8 @@
     "bin/",
     "src/",
     "public/",
+    "plugin/",
+    "plugin-code-critic/",
     "README.md",
     "LICENSE"
   ],
@@ -26,8 +28,9 @@
     "test:e2e": "playwright test",
     "test:e2e:headed": "playwright test --headed",
     "test:e2e:debug": "playwright test --debug",
+    "generate:skill-prompts": "node scripts/generate-skill-prompts.js",
     "changeset": "changeset",
-    "version": "changeset version",
+    "version": "changeset version && node scripts/sync-plugin-versions.js && git add .claude-plugin/marketplace.json plugin/.claude-plugin/plugin.json plugin-code-critic/.claude-plugin/plugin.json",
     "release": "npm whoami > /dev/null || { echo 'Error: Not logged in to npm. Run: npm login'; exit 1; } && npm run version && changeset tag && npm publish && git push && git push --tags"
   },
   "keywords": [
@@ -55,6 +58,7 @@
   },
   "homepage": "https://github.com/in-the-loop-labs/pair-review#readme",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
     "@octokit/rest": "^19.0.11",
     "better-sqlite3": "^11.8.1",
     "express": "^4.18.2",

package/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "pair-review",
+  "version": "1.2.0",
+  "description": "pair-review app integration — Open PRs and local changes in the pair-review web UI, run server-side AI analysis, and address review feedback. Requires the pair-review MCP server.",
+  "author": {
+    "name": "in-the-loop-labs",
+    "email": "tjwp@inthelooplabs.com"
+  },
+  "homepage": "https://github.com/in-the-loop-labs/pair-review",
+  "repository": "https://github.com/in-the-loop-labs/pair-review",
+  "license": "GPL-3.0-or-later",
+  "keywords": [
+    "code-review",
+    "pull-request",
+    "ai",
+    "pair-programming",
+    "feedback-loop",
+    "mcp"
+  ]
+}

package/plugin/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "pair-review": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@in-the-loop-labs/pair-review", "--mcp"]
+    }
+  }
+}

package/plugin/skills/ai-critic/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: ai-critic
+description: >
+  Fetch AI-generated review suggestions from pair-review and make code changes to address them.
+  Use when the user says "address AI feedback", "address AI suggestions", "fix AI review feedback",
+  or wants to iterate on code based on AI analysis results from pair-review.
+---
+
+# AI Critic
+
+Fetch AI-generated suggestions from pair-review and make code changes to address the valid ones.
+
+## Determine review context
+
+Determine whether this is a local review or a PR review:
+
+1. If the user explicitly says "local", use local mode.
+2. Otherwise, determine the GitHub owner, repo, and PR number for the current branch. If a PR exists, use PR mode with `repo` and `prNumber` params.
+3. If no PR exists, use local mode with `path` (absolute cwd) and `headSha` (`git rev-parse HEAD`) params.
+
+## Fetch AI suggestions
+
+Call `mcp__pair-review__get_ai_suggestions` with the review context params. This returns suggestions from the latest analysis run by default.
+
+If the user wants suggestions from a specific analysis run, call `mcp__pair-review__get_ai_analysis_runs` first to list available runs, then pass the appropriate `runId` to `get_ai_suggestions`.
+
+Only active and adopted suggestions are included (dismissed ones are excluded).
+
+If no suggestions are returned, tell the user there are no AI suggestions to address.
+
+## Triage and address suggestions
+
+AI suggestions are not human-curated — apply judgment. For each suggestion:
+
+1. Read the file at the referenced path and lines.
+2. Evaluate the suggestion: is it a real issue, a false positive, or a stylistic preference?
+3. If the suggestion is valid and actionable, make the code change.
+4. If the suggestion is a false positive or not worth addressing, skip it and note why.
+
+Use the `ai_confidence` field as a signal but not a hard threshold — low-confidence suggestions can still be valid.
+
+## Report
+
+After processing all suggestions, provide a summary:
+- How many suggestions were reviewed
+- Which ones were addressed (and what changed)
+- Which ones were skipped (and why)

package/plugin/skills/analyze/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: analyze
+description: >
+  Perform AI-powered code review analysis using pair-review's server-side analysis engine via MCP.
+  Requires the pair-review MCP server to be connected. For standalone analysis without MCP,
+  use the `code-critic:analyze` skill instead.
+  Starts analysis via the pair-review MCP start_analysis tool, polls for completion,
+  then fetches and presents the curated suggestions. Results are also visible in the
+  pair-review web UI alongside the diff.
+  Use when the user says "analyze in the app", "analyze in the UI", "run server analysis",
+  "analyze with pair-review", or wants analysis results integrated into the pair-review web UI.
+  If the user says something ambiguous like "analyze my changes" or "run analysis" without
+  specifying a method, and both the `code-critic:analyze` and `pair-review:analyze` skills are available,
+  ask whether they want: (1) agent-based analysis (`code-critic:analyze` — results returned
+  directly in the conversation, no server required), or (2) in-app analysis
+  (`pair-review:analyze` — results appear in the pair-review web UI, requires MCP connection).
+  If only one analysis skill is available, use it directly without asking.
+arguments:
+  tier:
+    description: "Prompt tier: fast (surface/Haiku-class), balanced (standard/Sonnet-class, default), or thorough (deep/Opus-class)"
+    required: false
+    default: balanced
+  skipLevel3:
+    description: "Skip Level 3 (codebase context) analysis. Useful for small or isolated changes."
+    required: false
+    default: false
+  customInstructions:
+    description: "Optional repo or user-specific review instructions"
+    required: false
+---
+
+# Analyze Changes (Server-Side via MCP)
+
+Perform a three-level code review analysis using pair-review's built-in analysis engine. Unlike the `code-critic:analyze` skill (which spawns analysis agents directly within the coding agent's context), this skill delegates all analysis work to the pair-review server via MCP tool calls. Use this skill when the pair-review MCP server is connected; use `code-critic:analyze` when it is not.
+
+**Prerequisites**: The pair-review MCP server must be connected with the `start_analysis`, `get_ai_analysis_runs`, and `get_ai_suggestions` tools available.
+
+## 1. Gather context
+
+Determine what is being reviewed:
+
+- **Local changes**: Run `git rev-parse HEAD` to get the HEAD SHA, and use the current working directory as the path.
+- **PR changes**: Determine the repository (`owner/repo`) and PR number. If the user provides a PR URL, extract these from it. If available, run `gh pr view --json number,headRepository` or similar.
+- If the user specifies a particular scope, use that.
+
+Collect:
+- Whether this is local or PR mode
+- For local: the absolute path and HEAD SHA
+- For PR: the `owner/repo` string and PR number
+
+## 2. Start analysis
+
+Call the `start_analysis` MCP tool with the appropriate parameters:
+
+**For local mode:**
+```json
+{
+  "path": "/absolute/path/to/repo",
+  "headSha": "abc123...",
+  "tier": "balanced",
+  "skipLevel3": false,
+  "customInstructions": "optional instructions"
+}
+```
+
+**For PR mode:**
+```json
+{
+  "repo": "owner/repo",
+  "prNumber": 42,
+  "tier": "balanced",
+  "skipLevel3": false,
+  "customInstructions": "optional instructions"
+}
+```
+
+Pass the `tier`, `skipLevel3`, and `customInstructions` arguments from the skill invocation.
+
+The tool returns immediately with `{ analysisId, runId, reviewId, status: "started" }`.
+
+## 3. Poll for completion
+
+Analysis typically takes 1-5 minutes depending on the size of the changes and the tier.
+
+Poll using `get_ai_analysis_runs` with `limit: 1` and the review coordinates from step 1. Wait approximately 10 seconds between polls.
+
+**For local mode:**
+```json
+{
+  "path": "/absolute/path/to/repo",
+  "headSha": "abc123...",
+  "limit": 1
+}
+```
+
+**For PR mode:**
+```json
+{
+  "repo": "owner/repo",
+  "prNumber": 42,
+  "limit": 1
+}
+```
+
+Verify that `runs[0].id` matches the `runId` returned from step 2 to ensure you are polling the correct analysis (another tab or user could have triggered a concurrent run).
+
+Check the `status` field in `runs[0]`:
+- `"running"`: Analysis is still in progress — keep polling
+- `"completed"`: Analysis finished — proceed to fetch results using the same `runId`
+- `"failed"`: Analysis failed — report the failure to the user
+
+Keep polling until `status` is `completed` or `failed`. Report progress to the user between polls.
+
+## Error handling
+
+- If `start_analysis` returns an error, report it to the user with the error message. Common causes: the PR has not been loaded in pair-review yet, the worktree is missing, or invalid parameters.
+- If polling shows `status: "failed"`, report the failure to the user. The `error` field in the run object contains the failure reason.
+- If `get_ai_suggestions` returns an empty list after a completed analysis, this means no issues were found -- report a clean result.
+
+## 4. Fetch results
+
+Once the analysis is complete, call `get_ai_suggestions` to retrieve the curated suggestions.
+
+Pass the `runId` from step 2's `start_analysis` response (same value used for polling):
+
+```json
+{
+  "runId": "the-runId-from-step-2"
+}
+```
+
+If `runId` is unavailable, fall back to resolving by review coordinates:
+
+**For local mode:**
+```json
+{
+  "path": "/absolute/path/to/repo",
+  "headSha": "abc123..."
+}
+```
+
+**For PR mode:**
+```json
+{
+  "repo": "owner/repo",
+  "prNumber": 42
+}
+```
+
+This returns the final orchestrated suggestions from the latest analysis run.
+
+## 5. Report
+
+Present the curated suggestions to the user, organized by file. For each suggestion show:
+- File and line reference
+- Type (bug, improvement, security, performance, praise, etc.)
+- Title and description
+- Confidence level
+
+Group suggestions by file for easy navigation. Highlight critical issues (bugs, security) prominently.
+
+If no suggestions were found, report that the analysis completed cleanly.

package/plugin/skills/local/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: local
+description: >
+  Open local uncommitted changes for review in the pair-review web UI.
+  This only opens the browser — it does not run AI analysis or generate suggestions.
+  Once open, the user can browse the diff, leave comments, and trigger analysis
+  from the web UI themselves.
+  Use when the user says "review my local changes", "review local", "open local review",
+  or wants to open a pair-review session for uncommitted work in the current directory.
+  If the user wants automated AI analysis of their local changes rather than just opening
+  the browser, use the `code-critic:analyze` skill (standalone, requires code-critic plugin) or `pair-review:analyze` skill (requires MCP server) instead. Note that the user can
+  also trigger AI analysis from within the pair-review web UI after opening it.
+---
+
+# Local Review
+
+Open the current working directory in the pair-review web UI for local code review.
+
+## Steps
+
+1. Call the `mcp__pair-review__get_server_info` tool to get the server URL.
+2. Get the absolute path of the current working directory.
+3. URL-encode the path.
+4. Open the browser: `open "{url}/local?path={encoded_path}"`
+
+If `get_server_info` fails or the MCP server is not connected, tell the user to start pair-review first:
+```
+npx @in-the-loop-labs/pair-review --mcp
+```

package/plugin/skills/pr/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: pr
+description: >
+  Open the GitHub pull request for the current branch in the pair-review web UI.
+  This only opens the browser — it does not run AI analysis or generate suggestions.
+  Once open, the user can browse the diff, leave comments, and trigger analysis
+  from the web UI themselves.
+  Use when the user says "review this PR", "review pull request", "open PR review",
+  or wants to open a pair-review session for the current branch's pull request.
+  If the user wants automated AI analysis of the PR rather than just opening the browser,
+  use the `code-critic:analyze` skill (standalone, requires code-critic plugin) or `pair-review:analyze` skill (requires MCP server) instead. Note that the user can also trigger
+  AI analysis from within the pair-review web UI after opening it.
+---
+
+# PR Review
+
+Open the current branch's GitHub PR in the pair-review web UI.
+
+## Steps
+
+1. Call the `mcp__pair-review__get_server_info` tool to get the server URL.
+2. Determine the GitHub owner, repo, and PR number for the current branch.
+3. Open the browser: `open "{url}/pr/{owner}/{repo}/{number}"`
+
+## Error handling
+
+- If `get_server_info` fails, tell the user to start pair-review first: `npx @in-the-loop-labs/pair-review --mcp`
+- If no PR exists for the current branch, tell the user.

package/plugin/skills/user-critic/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: user-critic
+description: >
+  Fetch human review comments from pair-review and make code changes to address them.
+  Use when the user says "address review feedback", "fix review comments", "address comments",
+  or wants to iterate on code based on feedback left by a human reviewer in pair-review.
+---
+
+# Address Review Feedback
+
+Fetch human-curated review comments from pair-review and make code changes to address each one.
+
+## Determine review context
+
+Determine whether this is a local review or a PR review:
+
+1. If the user explicitly says "local", use local mode.
+2. Otherwise, determine the GitHub owner, repo, and PR number for the current branch. If a PR exists, use PR mode with `repo` and `prNumber` params.
+3. If no PR exists, use local mode with `path` (absolute cwd) and `headSha` (`git rev-parse HEAD`) params.
+
+## Fetch comments
+
+Call `mcp__pair-review__get_user_comments` with the review context params.
+
+If no comments are returned, tell the user there's nothing to address.
+
+## Address each comment
+
+For each comment returned:
+
+1. Read the file at the referenced path and lines.
+2. Understand what the reviewer is asking for — it may be a bug fix, a refactoring request, a question, or a style change.
+3. Make the code change that addresses the feedback.
+4. If the comment is a question or unclear, explain your interpretation and what you changed.
+
+## Report
+
+After addressing all comments, provide a summary:
+- Which files were changed
+- What was done for each comment
+- Any comments that were ambiguous or could not be addressed (explain why)

package/plugin-code-critic/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "code-critic",
+  "version": "1.2.0",
+  "description": "AI-powered code review analysis — Run three-level AI analysis and implement-review-fix loops directly in your coding agent. Works standalone, no server required.",
+  "author": {
+    "name": "in-the-loop-labs",
+    "email": "tjwp@inthelooplabs.com"
+  },
+  "homepage": "https://github.com/in-the-loop-labs/pair-review",
+  "repository": "https://github.com/in-the-loop-labs/pair-review",
+  "license": "GPL-3.0-or-later",
+  "keywords": [
+    "code-review",
+    "ai",
+    "analysis",
+    "code-critic",
+    "critic-loop"
+  ]
+}