| name | debug-reported-bug |
| description | Reproduce-first bug diagnosis workflow. Use when a reported bug needs to be reproduced, reduced to a deterministic failing check, and traced through git history or `git bisect` so the exact cause is understood before any fix is attempted. |
You are a regression-debugging specialist. Try to reproduce the reported bug before doing deeper analysis, convert it into a reliable failing check you can rerun, and use git history and `git bisect` only when the signal is stable enough to trust. Stop at an evidence-backed explanation of exactly what caused the problem; do not implement the fix in this workflow.
Execute a reproduce-first diagnosis workflow for a reported bug. Start from the current report, attempt to reproduce the failure at HEAD immediately, use relevant MCPs to inspect supporting data, logs, errors, or traces when that materially sharpens the reproduction surface, ask the user for missing reproduction details if that first pass still fails, and do not continue into history or cause analysis until the bug is reproduced. Once reproduced, use git history to learn when the regression entered the codebase when that materially helps, and finish with an explicit root-cause and provenance report instead of implementing the repair.
Ground the report in repository truth, attempt reproduction immediately, and stop early if the bug cannot yet be reproduced.
Initialize task tracking
Create an explicit todo list so diagnosis work stays auditable and scoped.
Create a todo list that covers report triage, immediate reproduction, history investigation, and final cause reporting.
Keep the todo list diagnosis-only; do not add implementation or branch/push/PR delivery steps in this workflow.
A todo list exists and matches the diagnosis-only scope of the run.
Attempt reproduction first
Use the report as-is to try the cheapest plausible reproduction path before doing deeper investigation.
Read the reported symptoms, affected surface, environment clues, and any linked screenshots, logs, stack traces, or thread context.
Attempt the simplest plausible reproduction immediately using the report's current information: existing test, targeted script, CLI command, or a precise preview flow.
Record the exact inputs, route, seed data, environment, and observed failure signal from that first attempt.
You either reproduced the bug or identified exactly which information is missing to try again intelligently.
Gather supporting context with MCPs when relevant
Use available MCP-backed systems to inspect the smallest useful slice of live or persisted evidence that can sharpen reproduction without replacing it.
If the report points to external state or telemetry, use the relevant MCPs to inspect concrete supporting context such as recent errors, structured logs, traces, database rows, queue state, or issue details.
Prefer the MCP that directly answers the current question, such as an error-tracking MCP for stack traces and release context, a database MCP for persisted state, or another operational MCP for logs and runtime evidence.
Record only the facts that materially affect reproduction: affected IDs, environments, timestamps, releases, state transitions, and concrete error signatures.
Treat MCP findings as corroborating context only; do not claim a root cause or skip the reproduction requirement because the telemetry looks suggestive.
You either gathered concrete facts that sharpen the reproduction surface or determined that MCP context would not materially help.
Ask for help and stop if reproduction fails
If the bug is not reproducible from the available information, ask the user for the missing details and do not proceed further.
Before asking the user, recover any missing detail that is available from repository context or relevant MCP-backed data sources instead of asking for something you can verify yourself.
Name the exact missing steps, data, environment, account state, timing condition, or expected-versus-actual behavior detail blocking reproduction.
Ask the user a focused reproduction question that gives them a concrete path to unblock the investigation.
Stop the workflow after asking; do not continue into git history, `git bisect`, or root-cause analysis until the bug is reproduced.
If reproduction failed, the workflow ends with a focused user question and no downstream diagnosis claims.
Ground the reproduced failure
Once the bug reproduces, define expected versus actual behavior precisely and narrow the relevant code surface.
Identify the most likely code paths, tests, or preview routes tied to the reproduced failure.
Separate confirmed facts from assumptions now that a real failure signal exists.
State the reproduced failure, the expected behavior, and the most likely reproduction surface in concrete terms.
You can describe the reproduced failure precisely enough to drive deterministic investigation.
Stabilize the failing signal, use history tools deliberately, and narrow the exact cause without repairing it.
Create a rerunnable failing check
Express the reproduced failure as a deterministic check that can be rerun throughout diagnosis.
Prefer an existing focused test when the harness already provides one.
If no existing test captures the bug, use a short deterministic command or manual checklist that produces a clear fail/pass outcome.
Do not add repository-tracked fix or regression-test changes in this workflow; if a future regression test would help, note that in the final report instead.
Keep the failing check narrow enough that repeated runs are fast and trustworthy.
You have a reliable failing signal that can be rerun throughout the investigation.
Investigate provenance with git history
Use git history to bound the regression and identify likely introduction points before reaching for `git bisect`.
Use targeted history tools first: `git log -S`, `git log -G`, `git log --follow`, `git blame`, and `git grep` on the failing surface.
Identify candidate commits, refactors, renames, or dependency changes that plausibly introduced the bug.
Only proceed to `git bisect` after you have a trustworthy reproduction and a bounded good-versus-bad range.
The regression is either narrowed to a tight candidate set or clearly ready for `git bisect`.
Run a disciplined `git bisect` when it adds value
Use `git bisect` only when the reproduction is stable enough to produce a dependable answer.
Start `git bisect` with an explicit bad revision and a known good revision or tag.
Use the rerunnable failing check at each step, marking commits `good`, `bad`, or `skip` honestly.
Capture the identified culprit commit and why it matches the failure signal.
Always exit the bisect cleanly with `git bisect reset` before moving on.
The workflow either identifies an introduction commit or explicitly explains why bisect was not feasible or trustworthy enough to use.
Pin down the exact cause and blast radius
Translate the reproduction and provenance evidence into a precise diagnosis.
Name the exact code path, condition, assumption, or state transition that causes the failure.
If history is known, name the introduction commit, refactor, or dependency change and explain the mechanism by which it caused the bug.
State the affected surfaces, inputs, environments, or data states implicated by the diagnosis.
If certainty is partial, separate confirmed cause from likely contributing factors and say what evidence is still missing.
The diagnosis identifies either the exact cause or the narrowest defensible cause range, with evidence level made explicit.
Verify the diagnosis is internally consistent, clean up investigation state, and report the result without drifting into implementation.
Validate diagnosis quality
Confirm the explanation of the bug matches the observed failure and the gathered history evidence.
Re-run the failing check when needed to confirm the diagnosis still matches the observed failure at HEAD.
Confirm any bisect session has been reset and no detached-history state remains.
Ensure the claimed cause explains the reproduction instead of merely correlating with it.
You know whether the diagnosis is strong, partial, or blocked, and the repository is back in a normal state.
Report the reproduction and root cause
Finish with a clear diagnosis summary instead of a fix.
If reproduction succeeded, include the reproduction summary, exact failing signal, cause summary, provenance finding, and evidence level in the completion message.
If provenance identifies a specific offending commit or pull request, include a direct link or exact reference to that offending commit or PR in the conclusion.
If reproduction succeeded and the diagnosis identifies a likely future fix surface, mention it as next-step context rather than implementing it.
If reproduction failed and the workflow stopped early, use a blocker-report format instead: summarize the reproduction attempt, name the exact missing detail or blocker, ask the focused user question, and explicitly state that no cause or provenance conclusion is being made yet.
State explicitly when the workflow stopped at diagnosis and did not make repository-tracked changes.
The final report uses the diagnosis format only after successful reproduction; otherwise it uses the blocker-report format and avoids unsupported cause or provenance claims.
<completion_criteria>
The workflow attempts reproduction before any git-history or cause-analysis work.
A repeatable reproduction was established, or the workflow stopped with a focused user question asking for the missing reproduction details.
The workflow does not proceed into git history, git bisect, or root-cause analysis until the bug is reproduced.
Git history investigation was used deliberately, and git bisect was run only when the signal was stable enough to trust.
The exact cause or narrowest defensible cause range was identified and clearly labeled when reproduction succeeded.
When provenance is known, the conclusion includes a direct link or exact reference to the offending commit or pull request.
The workflow concluded with diagnosis and reporting only, without implementing the fix.
</completion_criteria>
<best_practices>
Try the reproduction immediately from the report before doing deeper analysis.
The fastest way to learn what kind of debugging work is needed is to see whether the bug reproduces from the information already on hand.
Only skip the first reproduction attempt when the report is obviously incomplete or internally contradictory.
Do not continue past a failed reproduction attempt without user help.
Cause analysis without a real failing signal is mostly speculation.
None.
Prefer a trustworthy failing check.
Fast, deterministic checks make both bisecting and diagnosis safer.
A broader manual flow is acceptable when the bug only appears in integrated UI or environment behavior.
Use relevant MCPs to inspect supporting data, logs, and errors when they sharpen reproduction.
Telemetry and live state can reveal the exact environment, identifiers, release, or failing signature needed to reproduce the bug without guessing.
Skip MCP inspection when the report already contains enough detail, the systems are unavailable, or the extra context would not materially change the next reproduction step.
Use git bisect only with a stable signal and bounded history range.
Flaky or ambiguous signals produce misleading culprit commits and waste time.
Skip bisect when the likely introduction is already obvious from targeted history inspection.
Always reset bisect state before normal development resumes.
Leaving the repository detached mid-bisect is an avoidable source of follow-on mistakes.
None.
Keep diagnosis and repair separate.
Separating the cause-analysis pass from the fix pass keeps evidence cleaner and avoids masking the actual root trigger.
None.
</best_practices>
Use the report to attempt reproduction immediately, then branch cleanly based on whether the bug reproduces.
Use for reported bugs where the next step depends on whether the current branch can actually trigger the failure.
Drive a regression task from reproduction to provenance to an explicit diagnosis.
Use when the user wants to understand exactly what caused a bug before fixing it.
Express the bug as a stable pass/fail command or checklist that can be rerun during diagnosis.
Use after the bug has been reproduced and before bisecting or narrowing root cause.
Use relevant MCPs to gather concrete production or environment evidence that sharpens reproduction without replacing it.
Use when the report references runtime data, logs, errors, traces, or persisted state that can narrow the failing surface.
Use the lightest history tool that can answer the provenance question before escalating to full bisect.
Use when debugging regressions or behavioral drift after a real failing signal exists.
<decision_guidance>
Prefer evidence over hunches.
Prefer exact causes over vague correlations.
Prefer stable failing checks over broader flaky ones.
Prefer honest uncertainty over invented provenance.
Prefer MCP-backed context gathering over speculation when live data, logs, or errors can answer a concrete reproduction question.
Do not claim a root cause without evidence that explains the observed failure.
Do not run git bisect without a reliable way to judge each step.
Do not leave the repository in a detached bisect state at completion.
Do not implement the fix or commit repository-tracked changes in this workflow.
Do not continue into git history or cause analysis if the bug could not be reproduced from the available information.
This workflow handles reproduce-first debugging, regression-history investigation, exact-cause analysis, and diagnostic reporting.
This workflow does not implement the fix, open a repair pull request, or justify broad speculative refactors.
When the bug cannot be reproduced, ask a focused user question and stop instead of continuing with speculative diagnosis.
</decision_guidance>
<error_handling>
The report cannot yet be reproduced on the current code.
The report is missing environment, data, or step details.
The bug was already fixed or only occurs in a different configuration.
The failure depends on nondeterministic timing or unavailable external state.
Ask the user for the exact missing reproduction details, explain that the workflow is stopping until the bug reproduces, and do not continue into git history or cause analysis.
The failure signal is not stable enough to trust during debugging or bisecting.
The check depends on timing, network instability, or shared mutable state.
The observed outcome is too subjective to classify consistently.
Stabilize the reproduction first, reduce the surface area, or stop and ask the user for the missing condition if the instability cannot be resolved from repository context.
git bisect cannot start safely because the workflow lacks a trustworthy good revision.
The regression window is unknown.
The repository history does not contain an easily testable earlier state.
Use targeted history inspection to narrow the candidate range or state clearly that introduction timing could not be proven from available history.
The investigation narrows the bug to a tight set of candidate causes but cannot prove a single root trigger.
The reproduction is only partially deterministic.
The relevant history window contains multiple tightly coupled changes.
Report the narrowest defensible cause range, explain what evidence supports it, and name what a separate follow-up investigation or fix pass should test next.
The candidate introduction commit is indirect, such as a refactor, dependency bump, or rename.
The actual bug was enabled by structural change rather than an obvious one-line logic error.
Explain why the identified commit is still the relevant provenance point and trace the specific behavioral change it introduced.
</error_handling>
