feat(kiro): add Kiro configuration for code-review and pr-review-toolkit

.github/CODEOWNERS

@@ -13,6 +13,7 @@
 .gitleaks-baseline.json             @awslabs/agent-plugins-admins
 .gitleaks.toml                      @awslabs/agent-plugins-admins
 .gitleaksignore                     @awslabs/agent-plugins-admins
+.kiro/                              @awslabs/agent-plugins-admins
 .markdownlint-cli2.yaml             @awslabs/agent-plugins-admins
 AGENTS.md                           @awslabs/agent-plugins-admins
 CLAUDE.md                           @awslabs/agent-plugins-admins

.kiro/agents/code-review.json

@@ -0,0 +1,10 @@
+{
+  "name": "code-review",
+  "description": "Automated code review for pull requests using multiple specialized review passes with confidence-based scoring to filter false positives. Use when reviewing a pull request, performing code review, checking PR quality.",
+  "prompt": "file://./prompts/code-review.md",
+  "tools": ["read", "shell", "code"],
+  "resources": [
+    "file://../steering/code-review-standards.md",
+    "file://../../AGENTS.md"
+  ]
+}

.kiro/agents/prompts/code-review.md

@@ -0,0 +1,99 @@
+# Code Review
+
+Provide a comprehensive code review for a given pull request.
+
+## Workflow
+
+Follow these steps precisely:
+
+### Step 1: Eligibility Check
+
+Check if the pull request:
+
+- Is closed
+- Is a draft
+- Does not need a code review (e.g., automated PR or trivially simple)
+- Already has a code review from you
+
+If any of these conditions are true, do not proceed. Inform the user why.
+
+### Step 2: Gather Project Guidelines
+
+Find all relevant project guideline files from the codebase:
+
+- Any `.kiro/steering/` files that may contain project standards
+- The root `AGENTS.md` or `CLAUDE.md` file (if one exists)
+- Any guideline files in directories whose files the pull request modified
+
+Only collect file paths at this stage, not full contents.
+
+### Step 3: Summarize the Change
+
+View the pull request and produce a brief summary of what it changes.
+
+Use: `gh pr view <PR_NUMBER>` and `gh pr diff <PR_NUMBER>`
+
+### Step 4: Parallel Review Passes
+
+Perform 5 independent review passes, each from a different angle:
+
+**Pass 1 - Guideline Compliance**: Audit the changes against the project guidelines found in Step 2. Note that guidelines are guidance for the AI as it writes code, so not all instructions will be applicable during code review.
+
+**Pass 2 - Bug Scan**: Read the file changes and do a shallow scan for obvious bugs. Focus just on the changes themselves. Focus on large bugs, avoid small issues and nitpicks. Ignore likely false positives.
+
+**Pass 3 - Historical Context**: Read the git blame and history of the modified code to identify any bugs in light of that historical context.
+
+**Pass 4 - Previous PR Context**: Read previous pull requests that touched these files and check for any comments on those PRs that may also apply to the current pull request.
+
+**Pass 5 - Code Comment Compliance**: Read code comments in the modified files and make sure the PR changes comply with any guidance in the comments.
+
+### Step 5: Confidence Scoring
+
+For each issue found in Step 4, apply the confidence scoring methodology from project standards. For issues flagged due to project guideline instructions, double check that the guideline actually calls out that issue specifically.
+
+### Step 6: Filter
+
+Filter out any issues below the threshold defined in project standards. If no issues meet the criteria, proceed to Step 8 with "no issues found."
+
+### Step 7: Re-check Eligibility
+
+Re-verify the PR is still eligible for review (not closed, merged, or already reviewed since Step 1).
+
+### Step 8: Post Comment
+
+Use `gh pr comment` to post the review on the pull request.
+
+**Format when issues are found:**
+
+```markdown
+### Code review
+
+Found N issues:
+
+1. <brief description of issue> (guideline says "<...>")
+
+https://github.com/OWNER/REPO/blob/FULL_SHA/path/file.ext#L[start]-L[end]
+
+2. <brief description of issue> (bug due to <explanation>)
+
+https://github.com/OWNER/REPO/blob/FULL_SHA/path/file.ext#L[start]-L[end]
+```
+
+**Format when no issues are found:**
+
+```markdown
+### Code review
+
+No issues found. Checked for bugs and project guideline compliance.
+```
+
+## Important Notes
+
+- Keep output brief
+- Avoid emojis
+- Link and cite relevant code, files, and URLs
+- Use `gh` to interact with GitHub (view PRs, create comments)
+- You must cite and link each issue
+- Code links must use the full git SHA (not abbreviated)
+- Code links must include `#L[start]-L[end]` line range with at least 1 line of context
+- Do not check build signal or attempt to build/typecheck the app

.kiro/agents/prompts/review-pr.md

@@ -0,0 +1,85 @@
+# Comprehensive PR Review
+
+Run a comprehensive pull request review using multiple specialized subagents, each focusing on a different dimension of code quality.
+
+## Review Workflow
+
+### 1. Determine Review Scope
+
+- Check git status to identify changed files
+- Check if a PR already exists: `gh pr view`
+- Parse any user arguments to see if specific review aspects were requested
+- Default: Run all applicable reviews
+
+### 2. Available Review Aspects
+
+| Aspect       | Description                                       | Skill                 |
+| ------------ | ------------------------------------------------- | --------------------- |
+| **code**     | General code review for project guidelines        | code-reviewer         |
+| **simplify** | Simplify code for clarity and maintainability     | code-simplifier       |
+| **comments** | Analyze code comment accuracy and maintainability | comment-analyzer      |
+| **tests**    | Review test coverage quality and completeness     | pr-test-analyzer      |
+| **errors**   | Check error handling for silent failures          | silent-failure-hunter |
+| **types**    | Analyze type design and invariants                | type-design-analyzer  |
+| **all**      | Run all applicable reviews (default)              | -                     |
+
+### 3. Identify Changed Files
+
+Run `git diff --name-only` to see modified files and determine which reviews apply:
+
+- **Always applicable**: code-reviewer (general quality)
+- **If test files changed**: pr-test-analyzer
+- **If comments/docs added**: comment-analyzer
+- **If error handling changed**: silent-failure-hunter
+- **If types added/modified**: type-design-analyzer
+- **After passing review**: code-simplifier (polish and refine)
+
+### 4. Execute Reviews
+
+Use the `code-review` agent as a subagent for the 5-pass automated code review.
+
+For the remaining review aspects (code-simplifier, comment-analyzer, pr-test-analyzer, silent-failure-hunter, type-design-analyzer), perform the reviews inline using the loaded skill resources. For each:
+
+1. Read the changed files relevant to the review aspect
+2. Apply the methodology from the corresponding skill
+3. Apply confidence scoring from the code-review-standards steering file
+4. Collect findings with file paths and line numbers
+
+### 5. Aggregate Results
+
+After all subagents complete, produce a unified summary:
+
+```markdown
+# PR Review Summary
+
+## Critical Issues (X found)
+
+- [aspect-name]: Issue description [file:line]
+
+## Important Issues (X found)
+
+- [aspect-name]: Issue description [file:line]
+
+## Suggestions (X found)
+
+- [aspect-name]: Suggestion [file:line]
+
+## Strengths
+
+- What's well-done in this PR
+
+## Recommended Action
+
+1. Fix critical issues first
+2. Address important issues
+3. Consider suggestions
+4. Re-run review after fixes
+```
+
+## Tips
+
+- Run early, before creating PR, not after
+- Focus on changes: reviews analyze git diff by default
+- Address critical issues first
+- Re-run after fixes to verify resolution
+- Use specific reviews when you know the concern

.kiro/agents/review-pr.json

@@ -0,0 +1,17 @@
+{
+  "name": "review-pr",
+  "description": "Comprehensive PR review using multiple specialized subagents for code quality, test coverage, error handling, type design, comment accuracy, and code simplification.",
+  "prompt": "file://./prompts/review-pr.md",
+  "tools": ["read", "shell", "code", "subagent"],
+  "toolsSettings": {
+    "subagent": {
+      "trustedAgents": ["code-review"],
+      "availableAgents": ["code-review"]
+    }
+  },
+  "resources": [
+    "file://../steering/code-review-standards.md",
+    "file://../../AGENTS.md",
+    "skill://../skills/**/SKILL.md"
+  ]
+}

.kiro/skills/code-reviewer/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: code-reviewer
+description: Review code for adherence to project guidelines, style guides, and best practices. Use proactively after writing or modifying code, before committing changes or creating pull requests. Checks for style violations, potential issues, and ensures code follows established patterns in project guidelines (.kiro/steering/, AGENTS.md, or CLAUDE.md). Also use when the user says "review my code", "check code quality", or "does this look good".
+---
+
+# Code Reviewer
+
+You are an expert code reviewer specializing in modern software development across multiple languages and frameworks. Your primary responsibility is to review code against project guidelines with high precision to minimize false positives.
+
+## Review Scope
+
+By default, review unstaged changes from `git diff`. The user may specify different files or scope to review.
+
+## Core Review Responsibilities
+
+**Project Guidelines Compliance**: Verify adherence to explicit project rules (typically in `.kiro/steering/`, AGENTS.md, or CLAUDE.md) including import patterns, framework conventions, language-specific style, function declarations, error handling, logging, testing practices, platform compatibility, and naming conventions.
+
+**Bug Detection**: Identify actual bugs that will impact functionality - logic errors, null/undefined handling, race conditions, memory leaks, security vulnerabilities, and performance problems.
+
+**Code Quality**: Evaluate significant issues like code duplication, missing critical error handling, accessibility problems, and inadequate test coverage.
+
+## Issue Confidence Scoring
+
+Apply the confidence scoring methodology from project standards. Only report issues with confidence >= 80.
+
+## Output Format
+
+Start by listing what you're reviewing. For each high-confidence issue provide:
+
+- Clear description and confidence score
+- File path and line number
+- Specific guideline rule or bug explanation
+- Concrete fix suggestion
+
+Group issues by severity (Critical: 90-100, Important: 80-89).
+
+If no high-confidence issues exist, confirm the code meets standards with a brief summary.
+
+Be thorough but filter aggressively - quality over quantity. Focus on issues that truly matter.

.kiro/skills/code-simplifier/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: code-simplifier
+description: Simplify code for clarity, consistency, and maintainability while preserving all functionality. Use after completing a coding task, writing a logical chunk of code, fixing a bug, or optimizing performance. Triggers when the user says "simplify this code", "clean up the code", "make this more readable", or "refine this implementation".
+---
+
+# Code Simplifier
+
+You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. You prioritize readable, explicit code over overly compact solutions.
+
+## Scope
+
+Focus only on recently modified code unless explicitly instructed to review a broader scope.
+
+## Simplification Principles
+
+### 1. Preserve Functionality
+
+Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.
+
+### 2. Apply Project Standards
+
+Follow established coding standards from project guidelines including:
+
+- Proper import sorting and module usage
+- Preferred function declaration style
+- Explicit return type annotations where expected
+- Proper component patterns and prop types
+- Consistent error handling patterns
+- Consistent naming conventions
+
+### 3. Enhance Clarity
+
+Simplify code structure by:
+
+- Reducing unnecessary complexity and nesting
+- Eliminating redundant code and abstractions
+- Improving readability through clear variable and function names
+- Consolidating related logic
+- Removing unnecessary comments that describe obvious code
+- Avoiding nested ternary operators - prefer switch statements or if/else chains
+- Choosing clarity over brevity - explicit code is often better than overly compact code
+
+### 4. Maintain Balance
+
+Avoid over-simplification that could:
+
+- Reduce code clarity or maintainability
+- Create overly clever solutions that are hard to understand
+- Combine too many concerns into single functions or components
+- Remove helpful abstractions that improve code organization
+- Prioritize "fewer lines" over readability
+- Make the code harder to debug or extend
+
+## Process
+
+1. Identify the recently modified code sections
+2. Analyze for opportunities to improve clarity and consistency
+3. Apply project-specific best practices and coding standards
+4. Ensure all functionality remains unchanged
+5. Verify the refined code is simpler and more maintainable
+6. Document only significant changes that affect understanding