- name
SKILL.md
Le fichier du skill reste dans le dépôt de l'éditeur.
Collez la commande copiée dans un terminal. Elle installe ce SKILL.md dans cet agent.
npx skills add Innei/ryugi --skill candidate -a cursor -yCollez la commande copiée dans un terminal. Elle installe ce SKILL.md dans cet agent.
npx skills add Innei/ryugi --skill candidate -a claude-code -yCollez la commande copiée dans un terminal. Elle installe ce SKILL.md dans cet agent.
npx skills add Innei/ryugi --skill candidate -a codex -yCollez la commande copiée dans un terminal. Elle installe ce SKILL.md dans cet agent.
npx skills add Innei/ryugi --skill candidate -a grok -yEnvoyez le message copié dans un chat Grok Bot. Le Bot récupère ce SKILL.md sur GitHub et l'ajoute aux skills que partagent tous vos Bots.
Install this skill: https://github.com/Innei/ryugi/tree/HEAD/docs/ryugi/skill-evals/2026-11-16-final-message/skills/candidateDe l'éditeur
Implement an approved spec yourself, task by task, in this session. You slice the spec into tasks, prove each one with a test you watched fail and then pass, and get one fresh-context review of the whole branch at the end.
Core principle: The spec says what to build; how to slice it is your call. Slice once, prove every slice, and leave a record that survives your own forgetting: the ledger is your memory, TDD is the per-task gate, and the final reviewer is the second pair of eyes.
Narration: between tool calls, narrate at most one short line — the ledger and the tool results carry the record.
Continuous execution: Do not pause to check in with your human partner between tasks. They approved the spec and chose inline execution so they would not have to answer "should I continue?". Execute every task without stopping. When they speak mid-run, do what they ask, answer it as ryugi:using-ryugi says, and take the next task.
Rulings, not stalls. Conflicts, ambiguities, gaps the spec is silent
on — decide them. The spec is the binding authority, your task list is
your reading of it, and your judgment settles what the spec does not
answer. Record every decision in the ledger as
Ruling: <what you decided> — <why> — <what it costs if wrong>, and keep
going. Deviating from the spec without a ledgered ruling is a decision
made in secret.
Four things stop you, and only these: an irreversible or destructive operation; a security-sensitive action; a side effect outside this working tree that norms say you ask about first (a merge, a push to a shared branch, a publish); and a spec so broken that every path forward is a guess. For those, stop and ask.
Task N headings works too: it already is a
task list, so skip the slicing step."Just code it" at the handoff means no spec execution: build the change under ryugi:test-driven-development and report.
REQUIRED SUB-SKILL: ryugi:using-git-worktrees decides whether you work in place or in a worktree, and creates the worktree. Follow its Where to work table before anything else.
In place, the checkout is shared:
git add -A, git add . or git commit -a.exploring.md in this directory before slicing.Conversation memory does not survive compaction, and an executor that loses its place re-implements tasks whose commits already exist. The ledger file is the record; harness todos are only a live view.
bash scripts/sdd-workspace SPEC_FILE — it prints the spec's
git-ignored directory (<repo-root>/.ryugi/sdd/<spec-basename>/),
home to this spec's task list, ledger, briefs and review packages.
Another spec's directory is never yours to read or write, apart from
reading its EXPLORING at Setup.<workspace>/progress.md. If its first line
names your spec file, tasks with a Task <N>: complete line are DONE —
do not redo them; resume at the first task without one. After
compaction, trust the ledger and git log over your own recollection.# SDD ledger — plan: <spec file path> (the scripts write this form).git clean -fdx will destroy the workspace (it's git-ignored scratch);
if that happens, recover from git log and the spec.Read the spec once, end to end.
REQUIRED SUB-SKILL: load ryugi:test-driven-development now, before slicing. It governs every task below.
Before Task 1, write <workspace>/tasks.md. If it already exists, this is
a resume: read it, never rewrite it.
Do not show the task list to your human partner for approval. They
approved the spec; the slicing is yours. Record it in the ledger as
Slicing: <N> tasks — <one line on how you cut it>.
Each task is a section under a ## Task <N>: <name> heading — the scripts
find tasks by that heading — with these parts, in order:
Produces: what later tasks use; Consumes: what it
uses from earlier tasks, by exact name.Expected: its result.
For a user-visible change, when the project has its own skill for
checking the running product (simulator, browser, local test run), name
it here too.Cut so that every task ends green and committable, and every Consumes:
matches an earlier task's Produces: exactly. Where the spec forces two
tasks into conflict, rule on it now with the spec as the authority.
End tasks.md with a ## Review Focus section: the inputs and failure
modes your tests will not exercise. The final reviewer checks each one
deliberately.
Create a todo per task.
Everything you print stays in your context for the rest of the session. Redirect long test output to a file in the workspace and read its tail; read a brief, not the whole task list.
bash scripts/task-start SPEC_FILE N. It prints the brief path and
BASE (the commit the task's range is cut from). Read the brief for every
task, including ones you remember writing: the brief has the exact
names and tests.Bookkeeping rides along with work: a ledger append goes in the same call as the commit, never in a call of its own.
Under ryugi:test-driven-development, loaded at setup: write the
brief's failing test, run it, and watch it fail for the expected reason. A
test that passes before the implementation exists is a finding about the
test. Then write the minimal code, run Verify, read its output, and
compare it against Expected:. Three outcomes:
Task <N>: Ruling: <finding> — <what you decided and why>,
fix the later tasks in tasks.md that it touches, and continue.A task that spans several commits is fine; BASE is what the review range
is cut from, never HEAD~1. In place, other agents' commits can land
inside BASE..HEAD: keep the SHA of every commit you make.
Before a task's ledger line, all of the following are true, with evidence in this session — not inferred from the diff looking right:
task-done is that run, and
it writes the command and result into the ledger line.Expected:.Ruling: line in the ledger.Evidence before claims (see ryugi:using-ryugi) governs the claim. If any item is missing, the task is not complete: finish it.
Run bash scripts/task-done SPEC_FILE N BASE -- <test command> with the
brief's Verify command. It runs the tests, keeps the full output in the
workspace, prints the tail, and — only if they pass — appends the
completion line to the ledger:
Task <N>: complete (commits <base7>..<head7>, tests: <command> → <result>)
In place, list your own commits instead of the range:
bash scripts/task-done SPEC_FILE N BASE <sha>... -- <test command>.
A failing run records nothing; the task is not complete. When it records, mark the todo complete and take the next task.
Run bash scripts/review-package SPEC_FILE MERGE_BASE HEAD
(MERGE_BASE = the commit the work started from, e.g.
git merge-base main HEAD) and review from the file it prints. In place,
run bash scripts/review-package SPEC_FILE --commits <sha>... with every
SHA from the ledger's Task <N>: complete lines, so other agents' commits
stay out of the package.
With a subagent tool: dispatch the reviewer on the most capable
available model — the whole-branch review is a judgment task — using
code-reviewer.md, filled with the package path, the
spec path, the ledger path for its Ruling: lines, and the
## Review Focus section of tasks.md verbatim.
Name the model explicitly; an omitted model inherits the session's. When
the harness cannot choose one, ledger Final review: session model and
go on; it is not news for your human partner. This
is the one fresh context the whole run buys. Do not skip it, and do not
replace it with your own read of the diff.
Without a subagent tool: read code-reviewer.md and perform that review
yourself against the package, as a separate pass after the last task's
ledger line. Write Final review: self-review (no subagent tool) to the
ledger, and list it among what needs your human partner: they decide
whether a self-review is enough before merge.
Sort the findings before you act on any of them. The reviewer's severity
labels are advice; the gate is yours. Its "Declined to judge" list is
yours too: every line there is a ruling you make and ledger —
Final: Ruling: <behavior the reviewer set aside> — <what a reasonable person using this software gets, and why that stands or why it is now a finding> — <cost if wrong>. Re-grade first, by effect: a finding's grade
is what a reasonable person using this software gets if it ships, not
whether the spec names the input that triggers it. Then:
Final: minor (deferred): <one-liner>.
Minors never enter the fix pass, and never become rulings.Fix the Critical and Important findings yourself in ONE pass. Each fix is
verified by TDD, not by a second reviewer: write the test that reproduces
the finding, watch it fail, make it pass, then run the whole suite. Record
each in the ledger as
Final: fixed <finding> — <test name> RED→GREEN, suite <N>/<N>. A fix
without a test that failed first is not verified; a suite that is not
green after the pass means the pass is not over. Do not dispatch a
re-review.
A finding you decide not to fix is a ruling — Final: Ruling: <finding> — <why the code stands> — <cost if wrong> — and reaches your human partner
in the rulings list. There is no second fix pass.
When the project has its own skill for checking the running product — launching the app in a simulator, driving a browser, a local test environment — run it now, on the finished branch, and keep what it showed as evidence for ryugi:verifying. Something it shows broken is a finding: fix it under TDD like a Critical one, and ledger it.
Use ryugi:verifying first; fixes for its rejects follow that skill. Then
collect every ledger line containing
Ruling:, in the order you made them, each with what it costs if wrong,
and every minor (deferred) line. Both lists are exhaustive: once the
workspace is gone they are the only record of those decisions.
Once they are written, delete this spec's workspace directory (never a
sibling's): the report and git history are the record now. Exploratory
work finishes as exploring.md says.
Your final message follows ryugi:using-ryugi. It carries the verify link and which groups wait on their verdict. The work is not done, and the ways to land it below wait, until every group that waits on them has passed.
Committed work in place on the default branch has nothing to land: name your commits from the ledger in one line, and stop. Pushing is your human partner's call.
On a branch, stop, and end your final message with the ways to land it:
<base> (default)<base>Landing is your human partner's call — use their project's shipping skill
when they name one. Whichever way it lands, <base> gets no merge
commit: "merge it" means squash; rebase only when they ask for it.
When they pick a way, read landing.md in this directory and follow it.
Use when an approved spec or design document is ready to implement and your human partner chose inline execution, or when they point you at a written design and ask you to build it in this session
---name: executing-specsdescription: Use when an approved spec or design document is ready to implement and your human partner chose inline…---# docs/ryugi/skill-evals/2026-11-16-final-message/skills/candidate/SKILL.mdFAQ
Téléchargez docs/ryugi/skill-evals/2026-11-16-final-message/skills/candidate/SKILL.md auprès de l'éditeur, ou copiez le chemin et ouvrez le dépôt. PlugMCP répertorie le skill et n'héberge pas le fichier.
L'éditeur le maintient sur https://github.com/Innei/ryugi.
Claude, Cursor, Codex et Grok Build peuvent lire un SKILL.md que vous ajoutez depuis le dépôt de l'éditeur. Grok Bot l'installe lorsque vous envoyez dans un chat le lien du dossier GitHub du skill.