gsd-pi 2.20.0 → 2.22.0

package/dist/resources/extensions/universal-config/index.ts

@@ -31,13 +31,13 @@ export default function universalConfig(pi: ExtensionAPI) {
     label: "Discover Configs",
     description:
       "Scan for existing AI coding tool configurations in this project and the user's home directory. " +
-      "Discovers MCP servers, rules, context files, and settings from Claude Code, Cursor, Windsurf, " +
+      "Discovers MCP servers, rules, context files, settings, Claude skills, and Claude plugins from Claude Code, Cursor, Windsurf, " +
       "Gemini CLI, Codex, Cline, GitHub Copilot, and VS Code. Read-only — never modifies config files.",
-    promptSnippet: "Discover existing AI tool configs (MCP servers, rules, context files) from 8 coding tools.",
+    promptSnippet: "Discover existing AI tool configs (MCP servers, rules, context files, Claude skills/plugins) from 8 coding tools.",
     promptGuidelines: [
       "Use discover_configs when a user asks about their existing configuration, MCP servers, or when switching from another AI coding tool.",
       "The tool scans both user-level (~/) and project-level (./) config directories.",
-      "Results include MCP servers that could be reused, rules/instructions that could be adapted, and context files from other tools.",
+      "Results include MCP servers that could be reused, rules/instructions that could be adapted, context files from other tools, and Claude skills/plugins that could be imported.",
     ],
     parameters: Type.Object({
       tool: Type.Optional(
@@ -83,6 +83,8 @@ export default function universalConfig(pi: ExtensionAPI) {
             rules: allItems.filter((i) => i.type === "rule").length,
             contextFiles: allItems.filter((i) => i.type === "context-file").length,
             settings: allItems.filter((i) => i.type === "settings").length,
+            claudeSkills: allItems.filter((i) => i.type === "claude-skill").length,
+            claudePlugins: allItems.filter((i) => i.type === "claude-plugin").length,
             totalItems: allItems.length,
             toolsWithConfig: filtered.filter((t) => t.items.length > 0).length,
           },

package/dist/resources/extensions/universal-config/scanners.ts

@@ -8,6 +8,7 @@
  */
 
 import { readFile, readdir, stat } from "node:fs/promises";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join, basename, resolve } from "node:path";
 import { homedir } from "node:os";
 import type {
@@ -29,6 +30,30 @@ function source(tool: ToolInfo, path: string, level: ConfigLevel): ConfigSource
   return { tool: tool.id, toolName: tool.name, path, level };
 }
 
+function walkDirectories(root: string, visit: (dir: string, depth: number) => void, maxDepth = 4): void {
+  const skip = new Set([".git", "node_modules", ".worktrees", "dist", "build", "cache", ".cache"]);
+
+  function walk(dir: string, depth: number) {
+    visit(dir, depth);
+    if (depth >= maxDepth) return;
+
+    let entries: Array<{ name: string; isDirectory: () => boolean }> = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (skip.has(entry.name)) continue;
+      walk(join(dir, entry.name), depth + 1);
+    }
+  }
+
+  walk(root, 0);
+}
+
 async function readTextFile(path: string): Promise<string | null> {
   try {
     return await readFile(path, "utf8");
@@ -166,8 +191,8 @@ async function scanClaude(projectRoot: string, home: string, tool: ToolInfo): Pr
     }
   }
 
-  // Project-level MCP: .claude/.mcp.json or .claude/mcp.json
-  for (const relPath of [".claude/.mcp.json", ".claude/mcp.json"]) {
+  // Project-level MCP: .mcp.json (standard), .claude/.mcp.json, or .claude/mcp.json
+  for (const relPath of [".mcp.json", ".claude/.mcp.json", ".claude/mcp.json"]) {
     const fullPath = join(projectRoot, relPath);
     const content = await readTextFile(fullPath);
     if (content) {
@@ -208,6 +233,44 @@ async function scanClaude(projectRoot: string, home: string, tool: ToolInfo): Pr
     }
   }
 
+  // Claude skills: ~/.claude/skills/**/SKILL.md
+  const userSkillsRoot = join(home, ".claude/skills");
+  if (existsSync(userSkillsRoot)) {
+    walkDirectories(userSkillsRoot, (dir) => {
+      const skillFile = join(dir, "SKILL.md");
+      if (!existsSync(skillFile)) return;
+      items.push({
+        type: "claude-skill",
+        name: basename(dir),
+        path: dir,
+        source: source(tool, skillFile, "user"),
+      });
+    }, 5);
+  }
+
+  // Claude plugins: ~/.claude/plugins/**/package.json
+  const userPluginsRoot = join(home, ".claude/plugins");
+  if (existsSync(userPluginsRoot)) {
+    walkDirectories(userPluginsRoot, (dir) => {
+      const packageJsonPath = join(dir, "package.json");
+      if (!existsSync(packageJsonPath)) return;
+      let packageName: string | undefined;
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { name?: string };
+        packageName = pkg.name;
+      } catch {
+        packageName = undefined;
+      }
+      items.push({
+        type: "claude-plugin",
+        name: packageName || basename(dir),
+        packageName,
+        path: dir,
+        source: source(tool, packageJsonPath, "user"),
+      });
+    }, 4);
+  }
+
   // User-level settings: ~/.claude/settings.json
   const userSettings = join(home, ".claude/settings.json");
   const settingsContent = await readTextFile(userSettings);

package/dist/resources/extensions/universal-config/tests/discovery.test.ts

@@ -41,6 +41,8 @@ describe("discoverAllConfigs", () => {
       assert.equal(result.summary.totalItems, 0);
       assert.equal(result.summary.toolsScanned, 8);
       assert.equal(result.summary.toolsWithConfig, 0);
+      assert.equal(result.summary.claudeSkills, 0);
+      assert.equal(result.summary.claudePlugins, 0);
       assert.ok(result.durationMs >= 0);
     } finally {
       cleanup();
@@ -53,6 +55,8 @@ describe("discoverAllConfigs", () => {
       writeJson(join(testHome, ".claude.json"), {
         mcpServers: { "claude-mcp": { command: "node", args: ["server.js"] } },
       });
+      writeText(join(testHome, ".claude/skills/test-skill/SKILL.md"), "# Test skill");
+      writeJson(join(testHome, ".claude/plugins/test-plugin/package.json"), { name: "test-plugin" });
       writeText(join(testRoot, ".cursorrules"), "Use semicolons.");
       writeText(join(testRoot, ".github/copilot-instructions.md"), "Be helpful.");
 
@@ -61,7 +65,9 @@ describe("discoverAllConfigs", () => {
       assert.equal(result.summary.mcpServers, 1);
       assert.equal(result.summary.rules, 1);
       assert.equal(result.summary.contextFiles, 1);
-      assert.equal(result.allItems.length, 3);
+      assert.equal(result.summary.claudeSkills, 1);
+      assert.equal(result.summary.claudePlugins, 1);
+      assert.equal(result.allItems.length, 5);
     } finally {
       cleanup();
     }
@@ -103,6 +109,8 @@ describe("discoverAllConfigs", () => {
       assert.equal(result.summary.rules, 2);
       assert.equal(result.summary.contextFiles, 1);
       assert.equal(result.summary.settings, 1);
+      assert.equal(result.summary.claudeSkills, 0);
+      assert.equal(result.summary.claudePlugins, 0);
       assert.equal(result.summary.totalItems, 5);
     } finally {
       cleanup();

package/dist/resources/extensions/universal-config/tests/format.test.ts

@@ -16,6 +16,8 @@ const emptyResult: DiscoveryResult = {
     rules: 0,
     contextFiles: 0,
     settings: 0,
+    claudeSkills: 0,
+    claudePlugins: 0,
     totalItems: 0,
     toolsScanned: 8,
     toolsWithConfig: 0,
@@ -38,11 +40,17 @@ const populatedResult: DiscoveryResult = {
           source: { tool: "cursor", toolName: "Cursor", path: "/project/.cursor/mcp.json", level: "project" },
         },
         {
-          type: "rule",
-          name: "style",
-          content: "Use semicolons and strict TypeScript.",
-          alwaysApply: true,
-          source: { tool: "cursor", toolName: "Cursor", path: "/project/.cursor/rules/style.mdc", level: "project" },
+          type: "claude-skill",
+          name: "cursor-mdc-editor",
+          path: "/home/user/.claude/skills/cursor-mdc-editor",
+          source: { tool: "claude", toolName: "Claude Code", path: "/home/user/.claude/skills/cursor-mdc-editor/SKILL.md", level: "user" },
+        },
+        {
+          type: "claude-plugin",
+          name: "context-mode",
+          packageName: "context-mode",
+          path: "/home/user/.claude/plugins/marketplaces/context-mode",
+          source: { tool: "claude", toolName: "Claude Code", path: "/home/user/.claude/plugins/marketplaces/context-mode/package.json", level: "user" },
         },
       ],
       warnings: [],
@@ -66,7 +74,9 @@ const populatedResult: DiscoveryResult = {
     rules: 1,
     contextFiles: 1,
     settings: 0,
-    totalItems: 3,
+    claudeSkills: 1,
+    claudePlugins: 1,
+    totalItems: 5,
     toolsScanned: 8,
     toolsWithConfig: 2,
   },
@@ -86,10 +96,14 @@ describe("formatDiscoveryForTool", () => {
     const text = formatDiscoveryForTool(populatedResult);
     assert.ok(text.includes("2/8 tools with config"));
     assert.ok(text.includes("1 MCP server(s)"));
+    assert.ok(text.includes("1 Claude skill(s)"));
+    assert.ok(text.includes("1 Claude plugin(s)"));
     assert.ok(text.includes("Cursor"));
     assert.ok(text.includes("test-mcp"));
     assert.ok(text.includes("GitHub Copilot"));
     assert.ok(text.includes("copilot-instructions.md"));
+    assert.ok(text.includes("cursor-mdc-editor"));
+    assert.ok(text.includes("context-mode"));
   });
 });
 
@@ -107,5 +121,7 @@ describe("formatDiscoveryForCommand", () => {
     assert.ok(text.includes("2 of 8"));
     assert.ok(text.includes("Cursor"));
     assert.ok(text.includes("MCP: test-mcp"));
+    assert.ok(text.includes("Skill: cursor-mdc-editor"));
+    assert.ok(text.includes("Plugin: context-mode"));
   });
 });

package/dist/resources/extensions/universal-config/tests/scanners.test.ts

@@ -107,6 +107,24 @@ describe("Claude Code scanner", () => {
     }
   });
 
+  test("discovers Claude Code skills and plugins", async () => {
+    const { testRoot, testHome, cleanup } = makeTempDirs();
+    try {
+      writeText(join(testHome, ".claude/skills/test-skill/SKILL.md"), "# test skill");
+      writeJson(join(testHome, ".claude/plugins/test-plugin/package.json"), { name: "test-plugin" });
+
+      const { items } = await SCANNERS.claude(testRoot, testHome, getTool("claude"));
+      const skills = items.filter((i) => i.type === "claude-skill");
+      const plugins = items.filter((i) => i.type === "claude-plugin");
+      assert.equal(skills.length, 1);
+      assert.equal(plugins.length, 1);
+      if (skills[0]?.type === "claude-skill") assert.equal(skills[0].name, "test-skill");
+      if (plugins[0]?.type === "claude-plugin") assert.equal(plugins[0].name, "test-plugin");
+    } finally {
+      cleanup();
+    }
+  });
+
   test("discovers settings.json", async () => {
     const { testRoot, testHome, cleanup } = makeTempDirs();
     try {

package/dist/resources/extensions/universal-config/types.ts

@@ -80,11 +80,28 @@ export interface DiscoveredSettings {
   source: ConfigSource;
 }
 
+export interface DiscoveredClaudeSkill {
+  type: "claude-skill";
+  name: string;
+  path: string;
+  source: ConfigSource;
+}
+
+export interface DiscoveredClaudePlugin {
+  type: "claude-plugin";
+  name: string;
+  path: string;
+  packageName?: string;
+  source: ConfigSource;
+}
+
 export type DiscoveredItem =
   | DiscoveredMCPServer
   | DiscoveredRule
   | DiscoveredContextFile
-  | DiscoveredSettings;
+  | DiscoveredSettings
+  | DiscoveredClaudeSkill
+  | DiscoveredClaudePlugin;
 
 // ── Discovery result ──────────────────────────────────────────────────────────
 
@@ -105,6 +122,8 @@ export interface DiscoveryResult {
     rules: number;
     contextFiles: number;
     settings: number;
+    claudeSkills: number;
+    claudePlugins: number;
     totalItems: number;
     toolsScanned: number;
     toolsWithConfig: number;

package/dist/resources/skills/lint/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: lint
+description: Lint and format code. Auto-detects ESLint, Biome, Prettier, or language-native formatters and runs them with auto-fix. Reports remaining issues with actionable suggestions.
+---
+
+<objective>
+Lint and format code in the current project. Auto-detect the project's linter and formatter toolchain, run them against the target files, and report results grouped by severity with actionable fix suggestions.
+</objective>
+
+<arguments>
+This skill accepts optional arguments after `/lint`:
+
+- **No arguments**: Lint only files changed in the current working tree (`git diff --name-only` and `git diff --cached --name-only`).
+- **A file or directory path**: Lint only that specific path (e.g., `/lint src/utils`).
+- **`--fix`**: Automatically apply safe fixes. Can be combined with a path (e.g., `/lint src/ --fix`).
+- **`--fix` without a path**: Auto-fix changed files only.
+
+Parse the arguments before proceeding. If `--fix` is present, set fix mode. If a non-flag argument is present, treat it as the target path.
+</arguments>
+
+<detection>
+Auto-detect the project's linter and formatter by checking configuration files in the project root. Check in this order and use the **first match found** for each category (linter vs. formatter). A project may have both a linter and a formatter.
+
+**JavaScript/TypeScript Linters:**
+
+1. **Biome** — Look for `biome.json` or `biome.jsonc` in the project root.
+   - Lint command: `npx @biomejs/biome check .` (or `--apply` with `--fix`)
+   - Format command: `npx @biomejs/biome format .` (or `--write` with `--fix`)
+   - Biome handles both linting and formatting. No need for a separate formatter if Biome is detected.
+
+2. **ESLint** — Look for `.eslintrc`, `.eslintrc.*` (js, cjs, json, yml, yaml), `eslint.config.*` (js, mjs, cjs, ts, mts, cts), or an `"eslintConfig"` key in `package.json`.
+   - Lint command: `npx eslint .` (or `--fix` with `--fix`)
+   - Check `package.json` for the installed version. ESLint 9+ uses flat config (`eslint.config.*`).
+
+**JavaScript/TypeScript Formatters (only if Biome was NOT detected):**
+
+3. **Prettier** — Look for `.prettierrc`, `.prettierrc.*`, `prettier.config.*`, or a `"prettier"` key in `package.json`.
+   - Format check: `npx prettier --check .`
+   - Format fix: `npx prettier --write .`
+
+**Rust:**
+
+4. **rustfmt** — Look for `rustfmt.toml` or `.rustfmt.toml`, or `Cargo.toml` in the project root.
+   - Format check: `cargo fmt -- --check`
+   - Format fix: `cargo fmt`
+   - Lint: `cargo clippy` (if available)
+
+**Go:**
+
+5. **Go tools** — Look for `go.mod` in the project root.
+   - Format check: `gofmt -l .`
+   - Format fix: `gofmt -w .`
+   - Lint: `golangci-lint run` (if installed), otherwise `go vet ./...`
+
+**Python:**
+
+6. **Ruff** — Look for `ruff.toml` or a `[tool.ruff]` section in `pyproject.toml`.
+   - Lint command: `ruff check .` (or `--fix` with `--fix`)
+   - Format command: `ruff format .` (or `--check` without `--fix`)
+
+7. **Black** — Look for a `[tool.black]` section in `pyproject.toml`, or `black` in requirements files.
+   - Format check: `black --check .`
+   - Format fix: `black .`
+
+If no linter or formatter is detected, inform the user and suggest common options for their project type based on the files present.
+</detection>
+
+<execution>
+
+**Step 1: Determine target files**
+
+- If a path argument was provided, use that path.
+- If no path argument, get changed files:
+  ```bash
+  git diff --name-only
+  git diff --cached --name-only
+  ```
+  Filter to files that still exist on disk. If no files are changed, inform the user and offer to lint the entire project instead.
+
+**Step 2: Run the detected tools**
+
+Run the linter and/or formatter against the target files or directory.
+
+- **Without `--fix`**: Run in check/report mode only. Do NOT modify any files.
+- **With `--fix`**: Run with auto-fix flags enabled.
+
+When running formatters without `--fix`, show a preview of what would change:
+- For Prettier: use `--check` and list files that would change.
+- For Biome: use `check` without `--apply`.
+- For Black: use `--check --diff` to show the diff preview.
+- For Ruff: use `--diff` for format and standard output for lint.
+- For rustfmt/gofmt: use `--check` or `-l` to list files, then show a diff for up to 5 files using `diff <(command) file`.
+
+**Step 3: Parse and organize output**
+
+Parse the tool output and organize issues:
+
+```markdown
+## Lint Results
+
+### Errors (X issues)
+| File | Line | Rule | Message |
+|------|------|------|---------|
+| ... | ... | ... | ... |
+
+### Warnings (X issues)
+| File | Line | Rule | Message |
+|------|------|------|---------|
+| ... | ... | ... | ... |
+
+### Formatting
+- X files would be reformatted
+- [list files]
+
+### Summary
+- Total issues: X errors, Y warnings, Z formatting
+- Auto-fixable: N issues (run `/lint --fix` to apply)
+```
+
+**Step 4: Suggest fixes for common issues**
+
+For the most frequent issues, provide brief actionable guidance:
+
+- If the same rule appears 5+ times, suggest a bulk fix or config change.
+- For unused imports/variables, list them for quick removal.
+- For formatting-only issues, note that `--fix` will resolve them safely.
+- For issues that cannot be auto-fixed, provide a one-line explanation of how to resolve each unique rule violation.
+
+</execution>
+
+<critical_rules>
+
+1. **Never modify files without `--fix`**: Default mode is report-only. Respect the user's working tree.
+2. **Use the project's own config**: Do not invent lint rules. Use whatever config files exist in the project.
+3. **Use the project's installed version**: Always prefer `npx`, `cargo`, or the project-local binary. Do not use globally installed tools unless no local version exists.
+4. **Handle missing tools gracefully**: If a config file exists but the tool is not installed, inform the user and provide the install command (e.g., `npm install --save-dev eslint`).
+5. **Respect `.gitignore` and ignore patterns**: Do not lint `node_modules`, `dist`, `build`, `target`, `.git`, or other commonly ignored directories. Most tools handle this automatically; verify they do.
+6. **Limit output**: If there are more than 50 issues, show the first 30 grouped by severity, then summarize the rest with counts per file. Do not flood the user with hundreds of lines.
+7. **Exit cleanly**: After presenting results, do not take further action. Let the user decide next steps.
+
+</critical_rules>

package/dist/resources/skills/review/SKILL.md

@@ -0,0 +1,214 @@
+---
+name: review
+description: Review code changes for security, performance, bugs, and quality. Reviews staged changes, unstaged changes, specific commits, or PR-ready diffs.
+---
+
+<objective>
+Review code changes and provide structured feedback covering security, performance, bug risks, code quality, and test coverage gaps. This skill analyzes diffs and surrounding context to catch issues before they reach production.
+</objective>
+
+<context>
+This skill reviews code changes at various stages of the development workflow. It can review staged changes before a commit, unstaged work-in-progress, a specific commit, or the full set of changes on a branch that are ready for a pull request.
+
+The reviewer reads both the diff and the surrounding source files to understand intent and catch issues that only appear in context.
+</context>
+
+<core_principle>
+**FIND REAL ISSUES, NOT STYLE NITS.** Focus on problems that cause bugs, security vulnerabilities, performance degradation, or maintainability pain. Avoid nitpicking formatting or subjective style preferences unless they harm readability.
+</core_principle>
+
+<analysis_only_rule>
+**THIS SKILL IS READ-ONLY. DO NOT MODIFY CODE.**
+
+The purpose is to review and report findings. Making changes during review conflates the reviewer and author roles. Present findings and let the user decide what to act on.
+</analysis_only_rule>
+
+<quick_start>
+
+<determine_review_scope>
+
+Parse the user's input to determine what to review:
+
+1. **No arguments** - Review staged changes first. If nothing is staged, review unstaged changes.
+   - Staged: `git diff --cached`
+   - Unstaged: `git diff`
+   - If both are empty, review the most recent commit: `git show HEAD`
+
+2. **Commit hash argument** (e.g., `/review abc1234`) - Review that specific commit.
+   - `git show <hash>`
+
+3. **File path argument** (e.g., `/review src/foo.ts`) - Review unstaged changes in that file.
+   - `git diff -- <path>` then fall back to `git diff --cached -- <path>`
+
+4. **"pr" argument** (e.g., `/review pr`) - Review all changes since branching from main.
+   - `git diff main...HEAD`
+   - If on main, review `git diff HEAD~1`
+
+After obtaining the diff, if it is empty, inform the user that there are no changes to review and stop.
+
+</determine_review_scope>
+
+<gather_context>
+
+Before analyzing the diff:
+
+1. **Read changed files in full** - Do not review a diff in isolation. Read each modified file to understand the surrounding code, imports, types, and control flow.
+2. **Identify the tech stack** - Note languages, frameworks, and libraries in use. This affects what patterns are risky.
+3. **Check for related test files** - For each changed source file, look for corresponding test files. Note whether tests were updated alongside the changes.
+4. **Check for configuration changes** - If config files changed (env, CI, package.json, tsconfig, etc.), pay extra attention to side effects.
+
+</gather_context>
+
+<review_categories>
+
+Analyze the changes against each category below. Only report findings that are actually present. Skip categories with no issues.
+
+**A. Security Issues** (Severity: CRITICAL or HIGH)
+- Injection vulnerabilities (SQL injection, command injection, template injection)
+- Cross-site scripting (XSS) - unsanitized user input rendered in HTML
+- Authentication and authorization flaws (missing auth checks, privilege escalation)
+- Secrets or credentials hardcoded or logged
+- Insecure deserialization or unsafe eval usage
+- Path traversal or file access vulnerabilities
+- Missing input validation on external data
+
+**B. Performance Concerns** (Severity: HIGH or MEDIUM)
+- N+1 query patterns in database access
+- Unnecessary memory allocations in hot paths or loops
+- Blocking operations on the main thread or in async contexts
+- Missing pagination on unbounded queries
+- Redundant computation that could be cached or memoized
+- Large payloads without streaming or chunking
+
+**C. Bug Risks** (Severity: HIGH or MEDIUM)
+- Off-by-one errors in loops or array access
+- Null/undefined dereferences without guards
+- Race conditions in concurrent or async code
+- Incorrect error handling (swallowed errors, wrong error types)
+- Type mismatches or unsafe type assertions
+- Logic errors in conditionals (inverted checks, missing cases)
+- Resource leaks (unclosed connections, file handles, listeners)
+
+**D. Code Quality** (Severity: MEDIUM or LOW)
+- Unclear or misleading naming
+- Significant code duplication that should be extracted
+- Excessive complexity (deeply nested logic, functions doing too many things)
+- Dead code or unreachable branches
+- Missing or misleading comments on non-obvious logic
+- Inconsistency with patterns used elsewhere in the codebase
+
+**E. Test Coverage Gaps** (Severity: MEDIUM or LOW)
+- New logic paths without corresponding test cases
+- Changed behavior without updated tests
+- Edge cases not covered (empty inputs, boundary values, error paths)
+- Missing integration tests for new API endpoints or database changes
+
+</review_categories>
+
+<format_findings>
+
+For each finding, use this structure:
+
+```
+### [SEVERITY] Category: Brief Title
+
+**File**: `path/to/file.ext` (lines X-Y)
+
+**Issue**: Clear description of the problem.
+
+**Why it matters**: What could go wrong if this is not addressed.
+
+**Suggestion**: How to fix it, with a code snippet if helpful.
+```
+
+Severity levels:
+- **CRITICAL** - Must fix before merge. Security vulnerability or data loss risk.
+- **HIGH** - Should fix before merge. Likely bug or significant performance issue.
+- **MEDIUM** - Should fix soon. Code quality or moderate risk issue.
+- **LOW** - Consider fixing. Minor improvement opportunity.
+
+</format_findings>
+
+</quick_start>
+
+<critical_rules>
+
+1. **READ THE FULL FILE**: Never review a diff without reading the complete source file for context
+2. **NO FALSE ALARMS**: Only report issues you can explain concretely. Do not report vague concerns
+3. **PRIORITIZE**: Lead with the most severe findings. Do not bury critical issues under style nits
+4. **BE SPECIFIC**: Include file paths, line numbers, and code references for every finding
+5. **EXPLAIN THE RISK**: For each finding, explain what could actually go wrong
+6. **CHECK TESTS**: Always check whether changes have corresponding test updates
+7. **CONSIDER THE STACK**: Apply language-specific and framework-specific knowledge to your review
+8. **DO NOT MODIFY CODE**: Present findings only. The user decides what to act on
+
+</critical_rules>
+
+<output_format>
+
+```markdown
+## Code Review: [brief description of what was reviewed]
+
+**Scope**: [staged changes | unstaged changes | commit abc1234 | PR changes from main]
+**Files reviewed**: [count] files changed, [additions] additions, [deletions] deletions
+
+---
+
+### Findings
+
+[Findings grouped by severity, highest first. Use the format from <format_findings>.]
+
+---
+
+### Summary
+
+| Severity | Count |
+|----------|-------|
+| CRITICAL | X     |
+| HIGH     | X     |
+| MEDIUM   | X     |
+| LOW      | X     |
+
+### Recommended Actions
+
+1. [Most important action to take]
+2. [Next most important action]
+3. [...]
+```
+
+If no issues are found:
+
+```markdown
+## Code Review: [brief description]
+
+**Scope**: [what was reviewed]
+**Files reviewed**: [count]
+
+No significant issues found. The changes look good to merge.
+```
+
+</output_format>
+
+<decision_gate>
+
+**After presenting findings, ALWAYS offer these options:**
+
+```
+─────────────────────────────────────────
+REVIEW COMPLETE
+
+What would you like to do?
+
+1. **Fix issues** - I'll address the findings starting with the most critical
+2. **Save review** - Export findings to a markdown file
+3. **Review again** - Re-review with different scope or focus
+4. **Discuss a finding** - Ask questions about a specific issue
+5. **Other** - Tell me what you need
+─────────────────────────────────────────
+```
+
+**Wait for user response before taking any action.**
+
+This gate is MANDATORY. Never skip it. Never auto-implement fixes.
+
+</decision_gate>