by-carlos/daikenja / skills/judgement
judgement
VerifiedChecks 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.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 24.5 KB |
SKILL.md
View on GitHub---
name: judgement
description: '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.'
metadata:
owner: Carlos
version: 1
---
# 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
| Situation | What to do |
|---|---|
| Bare `judgement`, and nothing in the session is a link or a pasted block | Ask for a link, a path or a paste. Do not search for one. |
| Link given but no tool is connected for that source | Say which source and that no tool is connected; ask for a paste. |
| Fetched content is empty or truncated | Say so and ask for a paste. Never judge a partial subject silently. |
| The named project key is not registered | Stop: name the key and list the registered ones. Never fall back to the directory. |
| No project matches, and some registered projects have no card | Say 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 handle | Do not ask. Read no ledger, answer on general knowledge, and copy Step 3's `This looks like ...` sentence into `Suggestion`. |
| No match at all | The same, with Step 3's `No project context. ...` sentence instead. |
| None of the project's files exists | `No ledger yet in <home>. Run /daikenja:project-log to create one.`, then continue on general knowledge, saying so. |
| The project needs migration | `answer`: the `reading.md` notice line, and stop. `message`: the `needs-migration` line from Step 3, and no verdict. |
| A file carries a newer format version | `answer`: warn once and read it anyway. `message`: the `newer-format` line from Step 3, and no verdict. |
| A ledger line does not parse | Report 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 one | Decline per the hard rule; name `/daikenja:thread` and `/daikenja:compose`. |
| The user asks for the document to be fixed | Decline 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 subject | One 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.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| 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 implementation | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| 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 fallback | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| 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 always | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |