Add Copilot research & plan prompt files

.github/prompts/plan.prompt.md

@@ -0,0 +1,50 @@
+---
+description: "Planning phase — create an implementation plan based on research.md"
+---
+
+You are in the **planning phase**. Do NOT implement any code changes.
+
+Your job is to take the research from `research.md` and produce a clear, actionable implementation plan.
+
+## Steps
+
+1. **Read `research.md`**: Review the research document thoroughly.
+2. **Design the approach**: Based on the findings, determine the best implementation strategy.
+3. **Write `plan.md`**: Create a `plan.md` file in the project root, structured as follows:
+
+```
+# Plan: [Brief title]
+
+## Approach
+[High-level description of the chosen approach and why]
+
+## Changes
+
+### 1. [First change]
+- **File(s)**: `path/to/file`
+- **What**: [Description of the change]
+- **Why**: [Rationale]
+
+### 2. [Second change]
+- **File(s)**: `path/to/file`
+- **What**: [Description of the change]
+- **Why**: [Rationale]
+
+[...continue for each change]
+
+## Testing Strategy
+[What tests to add or update, and what to verify]
+
+## Rollout / Migration Considerations
+[Any backward compatibility, feature flags, or deployment concerns]
+
+## Open Questions
+[Anything that still needs a decision before implementation]
+```
+
+## Rules
+- Do NOT write any implementation code
+- Do NOT modify any existing files (except creating `plan.md`)
+- Each change should be small and clearly scoped
+- Order the changes so they can be implemented sequentially
+- Call out any decisions that need human input in Open Questions

.github/prompts/research.prompt.md

@@ -0,0 +1,46 @@
+---
+description: "Deep research phase — investigate an issue and the codebase, then write findings to research.md"
+---
+
+You are in the **research phase**. Do NOT implement any code changes.
+
+Your job is to deeply research the problem and the current codebase, then produce a research document.
+
+## Steps
+
+1. **Understand the problem**: Read the GitHub issue or problem description I provide carefully. Ask clarifying questions if the problem is ambiguous.
+2. **Examine the codebase**: Search through the relevant parts of the codebase to understand:
+   - How the current functionality works
+   - What files/modules are involved
+   - Any related patterns, utilities, or conventions already in use
+   - Any existing tests related to this area
+3. **Research external context** (if needed): Look up relevant documentation, APIs, or known issues that may inform the solution.
+4. **Write `research.md`**: Create a `research.md` file in the project root with your findings, structured as follows:
+
+```
+# Research: [Brief title of the issue]
+
+## Problem Summary
+[Concise description of what we're solving and why]
+
+## Relevant Code
+[List of key files, functions, and modules involved, with brief descriptions of what they do]
+
+## Current Behavior
+[How things work today in the area we're changing]
+
+## Key Findings
+[Important discoveries — gotchas, edge cases, dependencies, constraints]
+
+## External References
+[Links to docs, issues, or discussions that are relevant]
+
+## Open Questions
+[Anything that still needs clarification before we can plan a solution]
+```
+
+## Rules
+- Do NOT write any implementation code
+- Do NOT modify any existing files (except creating `research.md`)
+- Be thorough — this document will be the foundation for planning
+- Flag risks and unknowns explicitly