Kokusen — the black flash: one clean local commit, and nothing else

Nature: Manipulator. Prove this tree still does what it claims, then put exactly what was meant
onto this branch under a message that says what changed and why. Phase three of ren, after
`rasengan` authored the change and before `amaterasu`
launches; it opens nothing, touches no remote, and never pushes — publishing is hatsu:aka's.

The compile-before-commit is this skill's (ruling 2026-09-10,
`docs/ROSTER.md`): `breath` proves the base tip,
rasengan runs the declared checks as inner-loop feedback, and kokusen verifies the finished tree
and refuses to commit on red.

0. Standalone entry

`docs/STANDALONE-ENTRY.md` is the contract, and inside ren
this section is skipped. Cold, kokusen inherits state class S1, the turn boundary — changed
has no referent until this section supplies one.

P3 · The delta is `STANDALONE-ENTRY.md` § 3's — the fetched
origin/<branch.base> (or against <base>) diff plus git status --porcelain; name the resolved base
and both counts out loud. An empty union is a stop, not a commit: say there is nothing to record
and what would make that untrue.

P4 · Derive the lanes and name the mapping before running it, exactly as § 3's gate does; a
changed executable path matching no declared lane is its missing focused route, and
`tsukuyomi` § 0 holds the offer to author the missing tests.

P5 · Say what is not running — standalone entry: nothing authored anything in front of this, and
no report or bell follows it. § 8 still binds in full.

1. Invocation

P1 — this run opens with hatsu:ten kokusen (`ten` § 6 catches up this phase's
missing prerequisites under its own name; the phases this run calls skip theirs).

hatsu:kokusen [against <base>] [--type <feat|fix|chore|docs|refactor|test|perf|build|ci>] [--scope <scope>]

nen parse kokusen --grammar "against [<base>]" --line "<the invocation, minus the prefix and the flags>"

The parse runs only when the maintainer typed a clause; exit 2 asks, never drops it. With none,
the base is P3's fetched origin/<branch.base> — a fetch that cannot run is a stop, not a silent
fall-back — named either way.

Both flags hint § 5's message; with neither, type and scope are read off the diff and stated in the report.
One commit per coherent step — two separable things are two calls, not one bulleted message.

2. The parameters, and where they come from

Value	File → key
Trailers that may and may never appear	nen/workflow.json → commits.allowedAttributionTrailers, .forbiddenTrailers
The checks run over the tree before staging (§ 3)	nen/workflow.json → iteration.checks, iteration.lane
The base this branch is not	nen/workflow.json → branch.base
What the checks actually run	nen/contract.json → project.verbs.<lane>.<check>
The focused route for changed executable behaviour	an explicitly selected project.lanes.<scoped-lane> whose declared test argv is demonstrably scoped to that behaviour

When nen/workflow.json is absent, say so in these words — "no workflow.json: using the built-in
defaults from docs/WORKFLOW.md" — and use them. The defaults are the strict reading
deliberately: a repository that has said nothing about attribution gets the workflow's rule, not the
harness's habit. Any other missing argument or configuration item is asked for and set up inline
(missing-argument, missing-configuration; `WORKFLOW.md` § 4 Ask, set
up, continue); a missing scoped lane is authored by rasengan (missing-focused-route).

3. The verification gate — before anything is staged

The gate's five steps are `docs/WORKFLOW.md` § The local verification
gate, run here, now: the declared iteration.checks in order on
iteration.lane; a consumer's canon mirror regenerated and staged where .claude/canon-values.yml
changed (#111); the focused tests for changed executable behaviour through
`tsukuyomi`; the build proof read back only where step 1 ran a green build;
and nen wc classify proving this is not the trunk. What is this skill's is the refusal:
a 1 ends the commit — quote the failing check, commit nothing, hand the turn back to
`rasengan` (row red-lint, never a G5) and re-run the gate — a seat (exit
4) is not red, a missing focused route goes back to rasengan (row missing-focused-route),
and kokusen commits on a branch or not at all.

4. Triage — every path is looked at, some are asked about

Never git add -A blind.

nen stage triage --repo <path> [--scope <in-scope prefixes>] [--mentions "<the message you are about to write>"] [--large-bytes <n>]

It detects, never decides, and flagged alone decides the exit code, so a tree whose only
dirty rows are git-ignored is exit 0. One path can carry several reasons, and every flagged file
is presented with the reasons nen printed, one answer per file.

Kind	What it is	Default
secret-shape	.env, *.pem, *.key, credentials*, or a token/key shape in the diff	never askable (row secret-shape): no yes exists, the fix is to rotate or remove it, and "it is only local" softens nothing
local-config	the .local filename infix, deliberately not a directory rule	commit only when the request named it
large	at or over --large-bytes (default 1 MiB); a path that could not be measured is never flagged	skip
binary	—	commit only when the request named it
out-of-scope	omitted entirely when --scope is not passed	skip
unmentioned-deletion	a tracked path deleted whose basename is absent from --mentions	mention or skip
ignored	its own bucket, not a flag — a plain git add cannot stage it	skip

The six non-secret kinds are row staging-flag, resolved by those defaults. A secret-shape inside
an ignored tree is reported and left alone — it lands in ignored[] carrying ["ignored", "secret-shape"], is named once and is never rotated and never deleted, a third-party fixture not
being this repository's secret; unignored, the categorical rule applies with no softening. Relay
the verb's ignored: <n> file(s), not listed count; never compute one, and never re-partition the
rows: an ignored path that genuinely belongs is a deliberate -f the maintainer asks for by name.
--large-bytes is passed only where this repository has a real reason to differ, said out loud. Deliberately untracked leftovers stay untracked — offer
the .gitignore line, never commit something to be tidy. Passing --mentions the message you are
about to write is what makes unmentioned-deletion mean anything.

5. The message, and the commit

Both are `docs/WORKFLOW.md` § Writing a commit — the message and the
two streams: nen commit format --repo …'s shape validation, the canonical-trailer rule from that
document's § commits, the exit-code gate, the two-stream discipline and the exit table. What is this
skill's: the gate is § 3's, the staging is § 4's — stage explicitly, path by path, from § 4's
clean list plus every flagged path that got an explicit yes, and nothing else. Then
nen commit write --repo <path> --message-file <f> [--require-proof <lane>] [--dry-run] [--json]
makes the commit: it validates the file as commit format does, refuses a red proof and an empty
index, and reports {sha, subject, trailers}.

Then read the tip back — git -C <path> log -1 --format='%(trailers:only,unfold)' (§ 6): a
harness can append a trailer at git commit time (Cursor's Co-authored-by, zheref/hatsu#66). An
attribution key outside commits.allowedAttributionTrailers is a stop with a default —
WORKFLOW § commits's rule: a key ending -by/-with or in
forbiddenTrailers, case-insensitive; Closes is ordinary (nen/decisions.json row
injected-attribution-trailer): the tip just written is unpublished, so drop it with
git -C <path> reset --soft HEAD~1 — never an earlier commit, never an amend — and ask once for the
switch (row harness-attribution-switch, the maintainer's toggle); then re-run. aka § 7 reads every
outgoing commit before the push. Never --no-verify.

6. Residue

The explicit per-path git add, the tip read-back and its git -C <path> reset --soft HEAD~1 are
the raw calls (on the verb's --repo <path>) (PROCESS.md § Residue and owned dependencies; the read-back is
owned, nen#273). Of WORKFLOW § commits's three enforcement layers the
commit-msg hook exists only in a repository nen scaffold init stood up, so say which layers
the repository in front of you actually has. Whether two changes are one coherent commit is
judgment. Reusable focused selection is an owned dependency
(nen#207): use actual runner identifiers and separate
focused artifacts, never a probe-only lane of one language as focused tests for another's behaviour
and never one permanent lane per ad hoc selection, and a missing applicable focused path stays an
owned dependency, never a full-suite substitution.

7. Authority

• Permitted: run the lane's declared iteration.checks over the working copy; run the declared
  scoped test lanes; stage named paths; write one local commit per coherent step; drop the tip this
  step just wrote on an injected attribution key (§ 5; never an earlier commit); say what it contains.
• Not permitted: any push (that is hatsu:aka, human-called), any PR, label, merge, force,
  --no-verify, any amend of a published commit, any commit on the trunk — and no edit to the tree
  it is committing: a red check goes back to `rasengan`, never fixed here.
• Not a gate event, with one exception it raises rather than owns: a red check the turn cannot
  honestly clear is a G5 stop with the failing check quoted. The per-file ask on a flagged path is
  an in-session question, not a gate; a secret-shape is not a question at all.

8. Hard limits

• Never runs nen commit write on a message file nen commit format did not exit 0 for, and
  never merges the verb's two streams into that file.
• Never commits a flagged file without an explicit yes, and never commits a secret at all —
  there is no yes for secret-shape on a path this commit could contain. A secret-shape inside an
  ignored tree is reported and left alone, never rotated, never deleted.
• Never git add -A, never git add -f, never stages a path it did not name. -f is the
  maintainer's explicit call on one named path.
• Never adds untruthful or runtime attribution, and never certifies a prospective commit with
  forbidden attribution from any source.
• Never pushes, never force-pushes, never --no-verify, never commits on the trunk.
• Never stages anything before § 3's gate has run over THIS tree.
• Never commits over a red check, and never narrows one to clear it.
• Never reports a seat (exit 4) or a missing proof on a seated lane as a red build.
• Never runs full regression or coverage — those are kotoamatsukami's and byakugan's.