Skip to content

by-carlos/daikenja / skills/judgement

judgement

Verified

Checks a thread or a document against the project ledger and general knowledge and hands back a verdict: what is being claimed or asked, which parts a recorded decision settles, which parts are plain fact, and what is presented as settled without being established. Use when the user says "is this right?", "check this against the ledger", "give me a judgement on this thread", or asks for a quick "AI review summary" of a page or pull request to share with the team. Read-only -- it never drafts a reply, never edits the document and never writes the ledger.

Judgement

One subject, one verdict. The subject is a thread or a document; the verdict says what it claims or asks, checks that against the project's ledger first and against general knowledge second, and labels every statement with where it came from. It comes back in one of two forms: answer, a reply to the user in the conversation, or message, a deliverable a cold reader can be handed as it stands.

thread summarises and gathers; compose writes a reply; doc-review runs a fixed checklist over a document's own quality. This skill does none of those. It judges whether what the subject says holds up.

Hard rule: read-only, and never a reply

Do not draft a reply, a suggested wording or a message to send back into the thread. Not even in the message form: that form is an assessment written as an AI pass, headed as one, and it is never phrased as the user speaking. A user who wants to answer the thread runs /daikenja:thread and then /daikenja:compose.

Do not write the ledger, the card or daikenja.yaml. A contradiction this skill finds is reported; it is logged, if at all, by the user through /daikenja:project-log afterwards. A project this skill cannot resolve is not registered by it and gets no card from it.

Do not edit the document. A finding names what is wrong and where. The human edits.

Step 0: read the contracts

Read these before the first output:

  • ${CLAUDE_PLUGIN_ROOT}/docs/response-format.md -- the answer form is a conversational reply and follows it whole: answer first, findings itemised, entries named topic-first by their words, clean result in one line.
    • § The second person belongs to conversation governs the difference between the two forms: the answer form addresses the user as you, and the message form -- built to leave the session -- names people instead.
  • ${CLAUDE_PLUGIN_ROOT}/docs/project-card.md § Resolving a project by content and § Reading a card -- how a subject with no key and no directory finds its project, and what a card says.
  • ${CLAUDE_PLUGIN_ROOT}/docs/reading.md § Step B: resolve the ledger path and § Step C: read and parse -- how the ledger, every DECISIONS.md of the project plus its open.md, is found and read.
  • ${CLAUDE_PLUGIN_ROOT}/docs/voice.md -- the message form is generated output and follows it in voice-only mode; see § Voice in the message form.

The discipline is this skill's own

A user may have installed a conversational register of their own -- labelled response parts, a brevity rule -- through /daikenja:tensei or by hand. It is per user, may be absent and may be edited, so nothing here depends on it. The rules below are written into this skill so it behaves the same on every install:

  • Headline first. One line naming the subject, then the finding. Never an explanatory paragraph before the verdict.
  • Every statement is labelled with its source: ledger, with the decision named topic-first and the repository whose DECISIONS.md holds it in parentheses -- or (open item) for an item of open.md -- or general knowledge. There are no IDs: an entry is cited by its words. A statement with no label is a defect.
  • Every finding carries a confidence: certain, likely or guessing. A recommended action is framed as a suggestion. Confidence and suggestion are two different things; neither form blurs them into hedging.
  • Flag what the subject presents as settled but does not establish. "As agreed", "the standard says", "everyone knows" with nothing behind it is a finding, not a fact to carry forward.
  • Links only from evidence. A standard, page or source is linked only when the subject itself or the Sources section of open.md already carries that link. Otherwise name it by its human-readable title and mark it link needed. Never construct a URL, and never restate a standard owned by another team in place of naming it.
  • Close with one line saying what was not checked. An unstated scope exclusion is a defect of the review.
  • No padding. A clean result is one line.

The answer form still picks up an installed register when one is present, exactly as any other reply does, per response-format.md § A user-side conversational layer. The message form never does: it leaves the session.

Step 1: get the subject and the form

The argument rule. /daikenja:judgement with no argument works on the enclosing context; /daikenja:judgement <subject> works on that subject instead. In Claude Code there is no enclosing thread, so the bare form means the most recent link or pasted block in this session. When nothing in the session qualifies, ask for one and stop. Never guess, and never go looking for a thread or a page the user did not give.

Accepted subjects:

  • A Slack thread link. Fetch the full thread with the connected Slack tool, parent message and every reply. Do not work from the permalink text.
  • A Confluence page link, or any other document link. Fetch it with whatever tool is connected for that source. Use the live content.
  • A repository path, including a pull request or a file in the working tree. Read it.
  • Pasted text. Use it as-is. Do not go looking for more.

If a fetch fails, say what failed and ask for a paste. Do not judge a title or a summary in place of the content, and do not review a partial document silently -- say it is partial.

The form. answer is the default. message is chosen when the user asks for it by name (/daikenja:judgement message <subject>), or in plain words asks for something to share -- "for the team", "as a message", "an AI review summary", "something I can post". When the wording is ambiguous, produce the answer form; it is one line to ask for the other afterwards.

A caller that has an enclosing thread of its own -- a chat bot, a later consumer -- passes that thread as the subject and names the form. Nothing in this skill assumes a working directory or a terminal.

Step 2: triage the subject

Before checking anything, establish what the subject says. For a thread, the summary is the same six-line shape thread § Step 2: summarize it uses, and its attribution rules apply unchanged -- name who said what, keep a question apart from a proposal and both apart from a decision, and call an ambiguous position ambiguous:

🧵 **Thread** -- [what it is about, who is in it, and how many messages]
❓ **Asking** -- [who is asking, and what they actually want]
🔓 **Open** -- [what is still undecided]
⏳ **Waiting on** -- [name: what is theirs]
📒 **Ledger** -- [what the project already has on this -- see Step 2b]
🌡️ **Tone** -- [neutral / tense / urgent -- only if it is not neutral]

For a document, the same block with 📄 **Document** in place of 🧵 **Thread** (title and what kind of document it is), 📌 **Claims** in place of ❓ **Asking** (what it states as fact), and 🔓 **Open** for what it leaves undecided. Waiting on and Tone are omitted whenever they would be empty, for a thread as much as for a document.

Then list, for yourself, every factual claim and every question the subject carries, and for each claim whether the subject establishes it or merely presents it as settled. This list is what Step 4 checks. It is not shown to the user as a list; the findings are.

Do not flag ordinary workplace content. Names, roles, opinions and disagreements are the subject matter. The one exception is a credential, token, connection string or password: say so in one line and never copy it forward.

Step 3: place the subject

Resolve the project, in the order ${CLAUDE_PLUGIN_ROOT}/docs/config-resolution.md § Finding the project fixes, and stop at the first that resolves:

  1. A key the user named -- decisive, never falls back. An unknown key is reported with the registered keys and the run stops.
  2. The current directory, per reading.md § Step A. A caller with no working directory skips this route.
  3. The subject's content, per project-card.md § Resolving a project by content. A handle the subject names -- its channel, a tracker key, a repository, a document URL -- that exactly one card owns is a match, and that is the only way content resolves a project. A Scope fit is not a match and is never asked about, per that section's tier 2: read no ledger on the strength of it, carry on exactly as though nothing matched, and leave the Ledger section out.

Never ask which project applies. Produce the verdict first, on general knowledge, and put the project question at the end of it as an offer the person can take or ignore. Not checked says the ledger was not read, and the last bullet of Suggestion says which project was assumed, in one of two fixed forms:

No ledger read. This looks like <project name> -- say `<command> project <key>` to check it.
No project context. Add `<command> project <key>` if you want a ledger checked.

The first when a card's Scope nearly matched, the second when nothing did. The caller says how <command> is written; for the Slack bot it is @daikenja judgement. The sentence is copied, not composed -- a rule phrased as "name the candidate" produced a question in a real run instead, and a rule that allowed the question anywhere produced it here.

When a key or a directory resolved, still run the content check as a cross-check and report a decisive handle that points elsewhere as a mismatch, in one line, without switching project.

This skill is asked to resolve outright, so tier 3's non-match is said, not kept quiet: No registered project matches this content. <key> has no card, so it could not be checked. The verdict then continues on general knowledge alone, and both forms say plainly that no ledger was checked. It never falls back to an unrelated project's ledger, and it never treats the current directory's ledger as the subject's when the subject's own handles point nowhere.

Read what the project has, per reading.md § Step B: resolve the ledger path and § Step C: read and parse: the DECISIONS.md of every registered repository in full, not only the one under the current directory; the Open items of open.md in full; its Sources section (it is where a link may come from); and the card beside open.md per project-card.md § Reading a card. Name the files read and, when content decided, how the project was found -- the same line shapes thread § Step 2b uses -- and the card's path on the line after it when a card was read:

Ledger: <key> (<files>)                            key or directory
Ledger: <key>, matched by #<channel> (<files>)     decisive handle
Card: <absolute path>

<files> is every file read, absolute and comma-separated, a missing one marked (not created yet), per reading.md § Step B. A project with none of the files is reported with reading.md's own line and the run continues on general knowledge, saying so. A malformed line is reported and skipped, never repaired.

Project data unreadable. Two states stop the verdict, because a verdict over them would look normal and be wrong: the project needs migration (no repository in daikenja.yaml, or a legacy .daikenja/ledger.md with no open.md beside it, per reading.md § Step A and § Step B), or one of its files carries a newer format version than this plugin knows, per open-format.md § Version line. The answer form gives reading.md's notice line: a project that needs migration stops there, and a newer version is read anyway with its one warning, as every reading skill does. The message form -- the path a caller with no reader takes -- produces no verdict in either state. Its deliverable is exactly one line, copied, with nothing before or after it:

DAIKENJA-PROJECT-DATA-UNREADABLE <key> needs-migration
DAIKENJA-PROJECT-DATA-UNREADABLE <key> newer-format

<key> is the project key, or - for an unregistered directory. The notice line goes in the report around it, never in the message.

Step 4: check the claims

The ledger check comes first. Walk Step 2's list against the entries just read:

  • A claim or proposal that contradicts a decision in force -- name the decision topic-first with its repository, and quote the decision's own wording where the exact words matter. This is the most useful finding the skill can make and it leads the verdict.
  • A question the ledger already answers -- name the decision that answers it.
  • A claim or question that bears on an open item -- name the item, and whether the subject appears to resolve it. "Appears to resolve", never "resolved": only project-log resolves, and only on the user's say-so.
  • A claim the subject presents as settled that the ledger records as still open -- a finding of its own, labelled ledger.

Then general knowledge, for what the ledger does not cover: a plain factual error (one database engine cannot host another; a protocol does not do what the thread says it does), a question with a well-known answer, a claim that is true as stated. Each carries general knowledge and a confidence. A statement this skill is guessing at says guessing; it is not dropped to look more certain, and it is not padded to look more thorough.

Every DECISIONS.md entry is in force. The file holds no superseded wording to weigh, and this skill does not read git for what an entry replaced. When two repositories' entries disagree, name both.

What was not checked is decided here and written down in Step 5: a link in the subject that was not opened, a channel the thread refers to, a standard named but not read, a project that could not be checked for want of a card. One line, always present.

Step 5: report

Form answer

The conversational reply, per response-format.md. The summary block from Step 2 opens it; the conclusion follows; nothing precedes the block.

🧵 **Thread** -- ...
❓ **Asking** -- ...
🔓 **Open** -- ...
📒 **Ledger** -- ...
Ledger: <key>, matched by #<channel> (<absolute path>)
Card: <absolute path>

⚖️ **Verdict**
<one or two sentences that answer what the thread asks or judge what it
claims, each clause labelled>

🔍 **Basis**
1. **<topic>** -- the finding. _<certain | likely | guessing> · ledger, <topic> (<repository>)_
2. ...

💡 **Suggestion**
- <the action, or omitted>

🚧 **Not checked**
- <one line>

This form has no 📒 Ledger -- <project name> section of its own: the project is already established in the conversation and the Ledger: and Card: lines above already name it, so a second section would only restate that. message's 📒 Ledger section exists because its reader has neither -- a cold reader of the posted message never saw the Ledger:/Card: lines, so the finding needs its own section to carry that context.

The worked example from the design: a thread asks "are we going with X, and can SQL Server host Oracle?". The verdict reads Z was agreed for this project (the storage-engine decision, quill-gateway). SQL Server and Oracle are two different database engines; one cannot host the other -- certain, general knowledge. The first clause is cited to the ledger; the second is labelled as knowledge, not as ledger fact.

profile.tone scales the framing around the block and the findings, never the findings. A clean subject -- nothing contradicted, nothing unestablished, every question answered by the thread itself -- is one line: No findings. <subject> agrees with the ledger and makes no claim that does not hold. followed by the Not checked: line.

When no project resolved, the Ledger: line is replaced by the one-line non-match from Step 3, and the first item in Basis says the ledger check did not run. The ⚖️ **Verdict** sentence itself stays on the answer. Nothing else changes.

Form message

A shareable deliverable for a cold reader with medium knowledge of the domain: define a non-standard term in the sentence it first appears; do not explain what a practitioner already knows. No conversational markers, no emoji, no register labels, whatever the user has installed -- a consumer that cannot render them is the reason this form exists. Bulleted throughout, about 150 words, written as an AI pass and never as the user. Exactly this shape:

⚖️ **Verdict**
<one or two sentences that answer what the subject asks or judge what it
claims, each clause labelled with where it came from>

📒 **Ledger -- <project name>**
- **<decision or open item, topic-first>** (<repository> | open item) -- what
  the subject says, and how it bears on that entry. _<certain | likely | guessing> · ledger_

🔍 **Basis**
- **<topic>** -- the finding. _<certain | likely | guessing> · general knowledge_
- **<a claim presented as settled>** -- why it is not established.
  _<certain | likely | guessing> · not established_

💡 **Suggestion**
- <the action, as a suggestion>

🚧 **Not checked**
- <one line>

📒 Ledger is absent entirely when no project resolved. Not a bullet saying no ledger was checked -- absent. Why a project could not be resolved belongs in the short report around the message, never in the message: a reader who was not in the conversation cannot act on it, and it takes the most-read line of the deliverable to say that nothing happened. A resolved project is named by its human-readable name in the section header, never by a bare key alone. A second contradiction or dependency is a second bullet in the same section.

Every bullet opens with a bold topic and closes with an italic _<confidence> · <source>_. Confidence is certain, likely or guessing. Source is ledger, general knowledge, or not established for a claim the subject presents as settled without establishing it. Bold first and italic last is what makes the section skimmable: the reader takes the topics on one pass and the confidences on another.

Suggestion and Not checked are sections, not findings. Each is omitted only when it would be empty, and Not checked is never empty.

No header line, no Subject: line and no date. The surface carries all three -- a Slack app posts under its own name and timestamp, and a pasted block carries the context of wherever it was pasted. ⚖️ **Verdict** opens the message.

The section headers above are the bare words shown, with no trailing colon -- ⚖️ **Verdict**, not ⚖️ **Verdict:**. A colon after Ledger specifically is reserved for the Ledger: provenance line in the report around the message, and must stay distinguishable from this section's own 📒 **Ledger -- <project name>** header.

A bullet that wraps onto a second line indents the continuation. A second line that starts at the margin, with no indent and no bullet marker of its own, ends the block for a consumer that finds it by shape -- so a long bullet keeps unfinished text on the same line or indents the wrap.

No conversational markers and no register labels, whatever the user has installed. The markers above are this form's own structure and are fixed here; they are not tensei's, and the two sets never mix. No emoji beyond them, no preamble, no closing offer, and never a question -- there is nobody to answer one.

The deliverable is never wrapped in a code fence and never contains one, even when the subject it is assessing quotes a fenced snippet. A quoted line is named or restated inline -- in prose, or as inline code -- never fenced; the message is already handed back inside the report's own fence, and a fence nested inside it breaks on the way out.

A clean subject in this form is two sections: ⚖️ **Verdict** with its sentence, and 🚧 **Not checked** with its line. Nothing else -- except the Step 3 sentence saying which project was assumed, which a caller with no reader gets in 💡 **Suggestion** however clean the subject was, and whether or not a card nearly matched: it is the one thing the reader can act on, and it is the reason no ledger was checked.

Sources named in it follow the links rule: title first, a link only when the subject or the Sources of open.md already carry it, otherwise (link needed).

The message is handed back inside a fenced block so the user can copy it whole. Around it, a short report to the user -- the Ledger: and Card: lines from Step 3, why a project could not be resolved when that is the case, and anything that needs the user's own judgement: a Scope fit that was named but not read, a mismatch the cross-check found, a finding the user may not want shared, a term the reader might not know. That material goes in the report, never in the message; the message must stand without the conversation it came from.

Voice in the message form

The message form is generated output and follows ${CLAUDE_PLUGIN_ROOT}/docs/voice.md in full -- the ## Fixed tier and the ## Defaults tier as shipped. It runs in voice-only mode, defined in config-resolution.md § Voice and writing style: the user's writing_style prose is not read -- not resolved, not layered, and its absence is not a notice -- and personas is not read either. The message is an AI pass for a reader who was not in the conversation; the user's own greetings, turns of phrase and softening would misattribute it. Voice-only is not a user setting: this skill names it here, and only this form uses it.

The answer form is conversation, not generated output; voice.md does not govern it and response-format.md does.

Failure cases

SituationWhat to do
Bare judgement, and nothing in the session is a link or a pasted blockAsk for a link, a path or a paste. Do not search for one.
Link given but no tool is connected for that sourceSay which source and that no tool is connected; ask for a paste.
Fetched content is empty or truncatedSay so and ask for a paste. Never judge a partial subject silently.
The named project key is not registeredStop: name the key and list the registered ones. Never fall back to the directory.
No project matches, and some registered projects have no cardSay the non-match line naming the cardless projects, continue on general knowledge, and say no ledger was checked -- in both forms.
A Scope match, no decisive handleDo not ask. Read no ledger, answer on general knowledge, and copy Step 3's This looks like ... sentence into Suggestion.
No match at allThe same, with Step 3's No project context. ... sentence instead.
None of the project's files existsNo ledger yet in <home>. Run /daikenja:project-log to create one., then continue on general knowledge, saying so.
The project needs migrationanswer: the reading.md notice line, and stop. message: the needs-migration line from Step 3, and no verdict.
A file carries a newer format versionanswer: warn once and read it anyway. message: the newer-format line from Step 3, and no verdict.
A ledger line does not parseReport it per reading.md § Notices, shared wording and skip it. Never repair the file.
The subject asks for a reply, or the user asks for oneDecline per the hard rule; name /daikenja:thread and /daikenja:compose.
The user asks for the document to be fixedDecline per the hard rule; the findings say where. /daikenja:doc-review is the checklist review if that is what was meant.
A credential appears in the subjectOne line saying so; never copy it into either form.

What this skill does not do

  • It does not draft. The hard rule at the top is the whole of it, and the message form is an assessment, not a reply.
  • It does not write the ledger, the card or daikenja.yaml, and it does not register or scaffold anything. project-log and setup-project do, on the user's approval.
  • It does not run doc-review's checklist. Clarity, undefined terms and missing owners in the document's own text are that skill's findings; this skill judges whether the document's claims hold.
  • It does not post anywhere. A consumer that posts the message form into a chat surface is separate work and is not part of this skill.
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 322kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 322kUpdated Claude CodeCodexVerifiedInstall