門守KADOMORI

Pre-PR Evidence CLI

Shape AI-written changes into Pull Requests a human can take responsibility for.

Kadomori (“gatekeeper” in Japanese) is a CLI that organizes what was machine-checked, what needs human judgment, and what reviewers should be told — before the PR is created — and keeps it as verification evidence. Analysis runs entirely on your machine, and no code is sent anywhere by default. A tool for teams where merging requires human approval.

See how to install See how it works

A real recording of init → check → explain → split-plan → pr create --dry-run against an actual PR (35 files / +1174 / −201) — the same PR used in the samples below.

See real report.md / handoff.md samples from an actual PR →

壱 ── WHY

AI changed how fast code gets written.
The responsibility to approve it stayed human.

Ink drawing of a wooden balance scale: one tray overloaded with a tall stack of documents, the other holding a single seated reader
AI produces PRs in volume. The weight of verification piles up on the human side.

AI coding tools can now generate PRs fast and in volume. Yet the responsibility for approval and review remains with humans — for reasons of organizational structure, compliance, and liability.

This asymmetry does not go away, no matter how much AI models improve. As long as “a human verified this” remains a social and legal requirement, the human burden of verification grows in direct proportion to AI adoption.

Kadomori is a device that absorbs this structural burden at the Pre-PR layer. Before the PR goes out, it organizes what must be verified — with nothing falling through the cracks — and outputs it as verification evidence and a handoff that let a human take approval responsibility.

What Kadomori does not do

  • Replace code review
  • Declare mergeability or security safety
  • Mark anything “verified” on behalf of authors or reviewers
  • Auto-fix code, auto-commit, auto-push
  • Auto-comment on PRs, auto-split PRs

Kadomori is not a tool that adds more review volume. It suggests where human review seems needed, at what level, and why — organizing, without reducing, the material handed to your existing review process.

弐 ── WHAT’S DIFFERENT

“Asking an AI not to screw up isn’t verifiable.”

Two questions come up often: “why not just prompt the AI to be careful?” and “how is this different from post-PR AI reviewers?” The answers are verifiability, and layers.

Versus promptingWhether the check is verifiable

You can ask a coding agent, or a review agent you trained, not to make mistakes. But there is no way to confirm whether that request was honored on any given change.

Kadomori is rule-based and deterministic by default: the same diff produces the same output, in under a second for small-to-medium diffs, entirely on your machine. And the policy lives in kadomori.toml, not in someone’s prompt — version-controlled, shared, and reviewable by the team.

This is not a claim that Kadomori catches more. The only claim is that what was checked is left in a form you can verify.

Versus post-PR AI reviewersA different layer, so they stack

Tools like CodeRabbit, GitHub Copilot Code Review, Cursor Bugbot, and Greptile review the diff after the PR is opened, supporting the reviewer side. Kadomori works before the PR exists, on the author side, organizing the discussion points and the evidence.

Not a competitor but a layer that stacks. Teams already using a post-PR reviewer can place Kadomori in front of it as is.

参 ── WHO BENEFITS

Authors, reviewers, and the organization.
Each carries less of the weight of verification.

Kadomori is adopted by organizations where human approval is mandatory. Within them, it helps the three roles who write, read, and take responsibility for PRs every day.

AUTHOR

PR authors

Before
The cost of explaining, in your own words, code you didn’t entirely write. The fear of missing something. Taking criticism on a public PR.
With Kadomori
Before the PR, kadomori check lists AI-slop candidates, out-of-scope changes, and PR granularity. The handoff turns “what the author must verify” into an author checklist, so the material for your explanation is ready first.

REVIEWER

Reviewers, tech leads, EMs

Before
The cost of deciphering AI-generated PRs. Deciding what to look at, and how deeply. Oversized PRs and mixed changes.
With Kadomori
The Review Map classifies changes into machine-verified / context-needed / human-required. Where human eyes are needed — and why — arrives together with the PR, along with the questions reviewers are asked to decide.

ORGANIZATION

The organization

Before
No governance or audit trail for AI-generated code. No record of who verified what.
With Kadomori
report.json and the run history accumulate the facts of what was checked before each PR. Evidence Report exports period summaries as CSV / JSON. ACP-only design: code is never sent directly to an external LLM.

肆 ── HOW IT WORKS

Run your changes through one check
before the PR. That’s it.

Review Map — sorting the burden of verification into three colors

Changed files are classified by how much human attention they need, so review effort lands where it matters.

human-required
Human judgment required. Security, billing, DB schema — changes the person with approval responsibility should verify, with the reason attached.
context-needed
Background check needed. Changes that cannot be judged from the code alone and must be checked against specs or history.
machine-verified
Easy to verify mechanically. Changes that don’t need deep human attention are labeled as such, saving reviewer attention.

Analysis modes — always explicit about what produced each finding

Every report is headed by its analysis mode. It is metadata that prevents misreading which signal layer produced a finding — it never indicates review completion or safety. The three layers are cumulative.

Layer What it does
Default rulesNo LLM / under 1 second A low-noise entry point that works without an API key. Findings come from built-in path / diff rules only.
Team policyNo LLM / under 1 second Team-specific responsibility boundaries from kadomori.toml rules, or policy seeds imported from CODEOWNERS, PR templates, and framework conventions.
ACP LLMOptional / tens of seconds No Kadomori-owned LLM API. Semantic assistance comes only through your own already-vetted, user-managed agents (Cursor CLI, Claude Code, and so on) via ACP. On failure, it falls back automatically to the rule / policy layers.

Responsibility Handoff — the handover of responsibility, as a document

handoff.md is not a finished PR description. It is a verification memo the author works through, taking responsibility, before opening the PR — then hands to reviewers and approvers.

“What the author verifies before the PR” is always emitted as an unchecked author checklist. The tool never ticks a box. The human who bears responsibility does.

  • .kadomori/report.mdThe detailed report humans readView sample →
  • .kadomori/report.jsonFact data for audits and machine processing
  • .kadomori/handoff.mdThe handover document from author to reviewer to approverView sample →

The samples are not mockups: they are actual kadomori check output for a real PR in the Kadomori repository, run in English output mode. The report language is configurable (kadomori init --language en).

Ink drawing of two hands in kimono sleeves formally passing a folded document bearing a vermilion seal
Stamp the facts you verified, then pass them to the next person responsible.

伍 ── TRUST BY DESIGN

Analysis stays local.
Your code never goes to an external LLM.

Kadomori is designed to pass an organization’s security review. To the question “where does our code get sent?”, the default answer is: nowhere.

No external communication by default

No API key required. It runs fully on built-in rules, entirely on your machine — kadomori check works even on an air-gapped network.

LLM optional, and only via vetted agents

Kadomori has no LLM API of its own. If you enable AI assistance, it goes only through user-managed agents your organization has already vetted (ACP). On failure it falls back automatically to rule-based analysis.

All evidence stays on your machine

Reports and run history are written only to .kadomori/ inside your repository. GitHub operations go through the gh CLI without holding tokens, and diagnostic logs never print secret values.

陸 ── GETTING STARTED

One binary.
No Rust toolchain, no API key.

Three prerequisites: the target is a Git repository; there are committed changes against a base branch (e.g. main); and — only if you go as far as kadomori pr create — the GitHub CLI (gh) is authenticated.

1INSTALL

Install

Run the installer from the public releases. It fetches the binary matching your OS / architecture together with its .sha256, verifies the checksum, and installs.

curl -fsSL https://github.com/kinopeee/kadomori-releases/releases/latest/download/install.sh | sh
Invoke-WebRequest -Uri https://github.com/kinopeee/kadomori-releases/releases/latest/download/install.ps1 -OutFile "$env:TEMP\kadomori-install.ps1"
powershell -ExecutionPolicy Bypass -File "$env:TEMP\kadomori-install.ps1"
Remove-Item "$env:TEMP\kadomori-install.ps1" -Force

For enterprises, there is also a procedure that verifies the installer itself before running it (see “Verifying the installer” in the README).

2INIT

Initialize in your project and check the environment

init --auto-seed auto-detects CODEOWNERS and framework conventions and imports repository-specific seed rules. doctor checks Git, the base branch, gh auth, and more — read-only.

cd your-project
kadomori init --auto-seed --language en
kadomori doctor
3CHECK

Run your changes through the gate before the PR

Works without an LLM and generates the report and handoff. For small to medium diffs it finishes in under a second.

# State the goal (the PR's purpose); it drives out-of-scope detection
kadomori check --goal "Fix login form validation" --no-llm

# The goal can also be inferred from the branch name and commits
kadomori check --infer-goal --no-llm

From agents such as Cursor / Claude Code / Codex / Devin, the bundled vendor-neutral agent skill (/kadomori-check) runs the same check.

4HANDOFF

Hand over the evidence and open a draft PR

Review the handoff, tick the author checklist with your own hands, then create a draft PR via the gh CLI.

kadomori evidence handoff --goal "Fix login form validation" --no-llm
kadomori pr create --draft --title "fix: login form validation"

Kadomori never blocks. Combined with hooks / skills / CI, it still won’t stop a push or PR creation. Templates for git pre-push, Cursor hooks, and GitHub Actions are included.

Raising the gate takes one command.

Start with kadomori check --no-llm on your current branch. No API key, nothing sent anywhere — and the evidence for your next PR is already there.