Decisions

Keep the why attached to the code.

Decisions mined from ADRs, pull requests, commits and comments, linked to the files they govern, and aged when those files change.

One MCP call, get_why, returns the rationale before a refactor.

Repowise decisions for repowise-dev/repowise: candidates mined from pull requests, each with its quoted evidence and the paths it governs.

repowise-dev/repowise · decisions mined from pull requests and commits

At a glance

8
decision sources
ADRs, CHANGELOGs, PRs, markers, git, READMEs, comments, and agent transcripts.
3
verification states
Verified, fuzzy, and unverified remain explicit in the product.
get_why
agent retrieval
Returns rationale, evidence, lineage, and fallback archaeology in one MCP call.
0
LLM calls in PR risk
Governance-risk scoring remains deterministic.

Sound familiar?

The reason left with the person.

  • 01

    The engineer who knew why is on another team now.

  • 02

    The ADR folder has nine files and nobody opens it.

  • 03

    We re-litigate the same choice every quarter.

What makes it different

Rationale that finds you, not the other way round.

  1. Found, not filed

    Eight sources, one decision layer.

    ADRs, changelogs, PR bodies, inline markers, commit history, READMEs, comments and agent transcripts.

  2. Evidence

    Every decision shows the passage it came from.

    Verified, fuzzy or unverified, with the exact span behind the claim.

  3. Ages with the code

    A decision goes stale when its files change.

    Linked to the graph, so drift between the code and the rationale is visible.

  4. In review

    Pull requests that touch governed code get told.

    Ungoverned hotspots and contradictory decisions surface where the change happens.

On a real repository

The quote, the files it governs, and whether it still holds.

A decision record shows its status, the passage it came from, the files it governs and the decisions that refined or replaced it, so a reader can check the claim instead of taking it on trust.

A Repowise decision record: keep generation models independent, with a verified quote, its source and the modules and files it governs.
repowise-dev/repowise · one decision record

In plain words

The reasons behind the code, found where they were written down.

A decision is a claim about why the code is shaped a certain way, with the passage it came from. Repowise mines the eight places teams leave reasons, from formal ADRs to the commit message that mentions the outage, links each decision to the files it governs, and ages it as those files change.

How to read it

How much to trust a decision

Verified
The exact passage was found in the source. Quote it.
Fuzzy
The passage matched approximately. Read the evidence before relying on the wording.
Unverified
Recorded without a passage to back it, or added by a person and not yet confirmed.
Stale
Its governed files have changed since it was recorded. The why may no longer match the what.

How it works

Mined, verified, linked.

A decision is only useful if you can trust it and find it from the code it explains.
  1. 01 / Mine

    Read the places decisions hide

    Eight sources, from formal ADRs to the commit message that mentions the outage.
  2. 02 / Verify

    Attach the evidence

    Each decision carries its status and the spans that support it.
  3. 03 / Link

    Connect it to the graph

    Files, modules and the decisions that supersede or contradict it.

Questions

What people ask before they try it.

Where do the decisions come from?

repowise mines architectural decisions from eight sources, not just an ADR folder: ADR files, CHANGELOGs, PR bodies, inline markers in code, git archaeology, READMEs, comment archaeology, and agent transcripts. The result is a single decision layer that captures rationale wherever your team actually recorded it, even when they never wrote a formal record.

How are decisions verified?

Every decision carries a verification status: verified, fuzzy, or unverified. A verified decision is backed by concrete evidence spans, the exact passages in ADRs, commit messages, PR bodies, or comments that support it, so you can read the source and trust the claim. Fuzzy and unverified decisions are surfaced honestly instead of presented as fact, so nothing is invented without provenance.

What is decision lineage and supersession?

Decisions rarely stand alone. repowise connects them with supersedes, refines, and conflicts_with edges into a decision graph, so you can follow a chain from the original choice through every later revision. When a newer decision supersedes an older one, the lineage records it, and contradictory decisions are flagged instead of silently coexisting.

How does staleness work?

A decision is only as current as the code it governs. Each decision is linked to graph nodes, the files and modules it applies to, and it ages when those files get commits. As the governed code drifts away from the recorded rationale, repowise marks the decision as stale so you know when the why no longer matches the what.

What is get_why?

get_why is the MCP tool that returns architectural decision rationale in a single call: the decision, its status, the evidence spans behind it, and its supersession lineage chain. It is the tool an AI agent or a reviewer calls to answer why is the code shaped this way before a refactor. When no ADRs exist for a file, get_why falls back to git archaeology so you still get the most likely rationale instead of an empty answer.

How is this different from a regular ADR folder?

A folder of ADR markdown files only captures the decisions someone remembered to write down, and it never tells you when one goes stale. repowise mines eight sources, attaches a verification status and evidence spans, links each decision to the graph, tracks staleness as the code changes, connects decisions by lineage, and surfaces governance risk in PR reviews. It is the difference between a static archive and a living decision layer.

How do decisions show up in code review?

Decisions are governance-aware. They surface in PR risk reviews so reviewers see when a change touches code governed by an existing decision, when a hotspot has no decision governing it at all, and when two decisions contradict each other. The Repowise PR bot can flag these ungoverned hotspots and contradictory decisions deterministically, with no LLM in the scoring path.

Is the decision layer open source?

Yes. repowise is open source under AGPL-3.0, so every step of how decisions are mined, verified, linked, and aged is inspectable and reproducible on your own repo. The same decision layer is available self-hosted and on the paid hosted tier.

Last reviewed: October 2026

Get started

Ask why before you change it.

Index a public repository free and see which of its decisions Repowise can find and back with evidence.