Shared policy location: docs/DISCOVERY.md, docs/WORKFLOW.md,
docs/LAUNCH-MIGRATION.md, docs/STANDALONE-ENTRY.md, docs/PROCESS.md and docs/SURFACES.md belong to the resolved Hatsu plugin
root, not the consuming repository. On an installed surface, use the absolute root printed by
ten to read those files (re-resolve through that skill if unavailable). Relative links
below identify source locations; a missing consumer docs/ copy is not a missing policy and must not
trigger a duplicate filing. Never copy or invent a second policy in the target repository.

Mugetsu — the last cut: one release, one destination, on one recorded word

The gate on a declaration change is the REPOSITORY's role, not the file's kind. Maintainer's
ruling, 2026-09-18 (`docs/ROSTER.md` § Rulings of 2026-09-18 — G4 is
the repository's role, not the file's kind): G4 (CON-7) in a canon repository —
the repositories nen repo classify reports as role: canon (nen/repos.json → maintained_tools), whose product is the process — and G2
(CON-5) in a consumer repository, where a nen/contract.json, nen/workflow.json or
nen/gates.json is that repository's own configuration and governs nothing else. This skill runs
against consumer checkouts by design, so every declaration-gate instruction below names both
halves explicitly rather than asking you to reinterpret a bare "G4". The merge is en § 5's
either way — the ruling moves the gate, never the owner.

Nature: Emitter. Publication is the far end of the release line, and it is the one act in the
whole local plane whose blast radius is other people's users. That is what G3 (CON-6) holds,
and G3 is the maintainer's — never delegated, never inferred, never carried over.

You have said, in your own words, that this release goes to this destination. The tag is cut and
the preflight is clean. I will publish that, once, and quote what you said.

Mugetsu is a human call, per target, at G3. It is not a phase of any loop. Nothing upstream
finishing successfully brings the session here — not a green `/susanoo`,
not a merged release PR, not a cut tag, not a successful
`/kagutsuchi` upload to a staging channel. The one composite path is
the advance go (§ 3): the maintainer's own typed /futon … then …+mugetsu invocation, which
is a go given before the tag exists and is narrower than the ordinary one on every axis.

---

0. Standalone entry — this skill was ALWAYS standalone, and G3 is why

Mugetsu has no wired entry, by construction. § 1 already forbids every one: no composite ever
calls it on its own authority — not getsuga, not en, not mukai, not ren, and futon only as
the carrier of § 3's advance go, which is the maintainer's typed word and not the composite's — no
agent proposes it, a go with no tag is refused unless it is that advance go, and one go publishes one
target once. The contract in
`docs/STANDALONE-ENTRY.md` is explicit that it moves no gate
(§ 5), and this section is written to be read as subtracting rather than adding.

Nothing in this section is an authorisation. Not the warm-up, not the orientation block, not the
plan. The only thing that authorises a publication is § 3's recorded per-target go, in the
maintainer's own words, quoted verbatim — and a session that reaches this skill without one prints
the preflight and the plan, reports that it has no go, and stops. Two exceptions, both narrow: when
the maintainer typed /mugetsu [<target>] in this same turn, § 3 may ask for a destination only
where several are declared and none named — typed, never picked; and when the maintainer typed a
futon invocation whose then chain names this skill, § 3's advance go is the recorded go, bound to
the tag that run cuts. Every other reach, a subagent included, stops without relaying any ask. That is unchanged, and a cold entry is the case it was written for.

P1 · Warm up. `/ten mugetsu`, unconditionally (ten § 6 catches up auth and declarations, never the go) — nen release preflight and nen shu release are nen calls.

P2 · Orient, and put it above the preflight. State the branch, clean-or-dirty with paths, the
head's relation to the fetched origin/<branch.base>, the tag (§ 3's a go with no tag is
refused), and whether that tag is reachable from origin/<branch.base>. A publication is the one
operation in this system with no undo, so the state it runs from is stated before the preflight rather
than inferred from it.

P4 · Nothing is asked, and this is the strongest form of that rule in the plugin. Mugetsu does not
prompt for the go, does not offer to publish, does not present publication as an option in any picker,
and does not read a cold invocation as intent. The invocation is not the go: /mugetsu <target>
typed alone is half the authorisation, and § 3's recorded message is the other half. The go is typed,
never picked. The only question this skill may put is § 3's, for a missing part of a go, and only
when the maintainer typed /mugetsu <target> in this same turn: that completes their call and
prompts for nothing.

What a standalone entry explicitly does NOT become. Not a delegation (§ 1: a delegation is never
the go, and G3 is ruled not delegable). Not standing authority — it expires when the run ends, so a
second publication needs a second go. Not a subagent's self-authorisation, at this gate least of all.

Hand-back. Terminal. Nothing follows a publication in any wired run, because none reaches here.

---

1. Invocation — and who is allowed to say it

/mugetsu [<target>]

<target> names the destination — a key of nen/contract.json → project.targets where the
repository publishes through deploy, or the lane whose release row is the publication step where it
publishes through release (§ 4). By the maintainer's ruling of 2026-09-28 (`docs/ROSTER.md` § Rulings of 2026-09-26/27/28), naming it is
never mandatory, not even on a direct call: with none typed, this skill publishes to the
repository's single declared destination, and the version it publishes is the latest cut
(getsuga release) tag that has no published release yet — resolved at publish time, printed, and
quoted beside the go in the report. Only two or more declared destinations and none named is a
gap, asked as free text (missing-maintainer-choice; `WORKFLOW.md`
§ 4 The maintainer's word is never derived): the declared keys listed for reference, none starred,
none a picker option that publishes. The go itself is never derived or defaulted. An undeclared
target is refused, naming the declaration PR that would add it — a project.targets entry at that
repository's declaration gate — and nothing is written or run here.

The call is the maintainer's, in their own words or by name. Four consequences, all binding:

• No agent ever prompts for it (nen/decisions.json row release-go, a human gate at G3). Not a report, not a bell, not a stop's options, not a release PR
  body, not a composite offering it as a next step. A report may say the tag is cut and the
  production target is declared; it may not say shall I publish? An agent that asks for
  permission it was told to wait for has converted a human gate into a nudge, and this is the gate
  where that costs the most. Asking for the missing part of a go the maintainer's own invocation
  started in this same turn (§ 3, P4) proposes nothing: it completes their call.
• No composite ever calls it on its own authority. `/getsuga`,
  `/en`, `/mukai` and `/ren`
  never reach this skill, from any path. getsuga prints a deploy plan at its G3 stop and stops
  there; its own § 8 forbids the rest. `/futon` reaches it only as a
  typed then step carrying the advance go (§ 3) — the maintainer's own invocation, not the
  composite's plan — and never under futon's CON-25 delegation.
• One go, one target, one publication. A go for the iOS App Store is not a go for Google Play,
  for the web production environment, or for the same store's next build. Each is its own call, its
  own quoted go, and its own run of this skill.
• The go is not standing authority. It expires when this run ends — an advance go (§ 3) when the
  futon run that carries it ends or stops. A second publication needs a second message.

On a delegated session — the maintainer AFK, with rules recorded — a delegation is NOT the go, and
there is no arrangement under which it becomes one. G3 is ruled not delegable:
`docs/ROSTER.md` § The human gates, and who may cross them gives it as
"Never. Preparing a release is allowed; publishing is not", and
`docs/delegation-grammar-DRAFT.md` § Never delegated,
inside a run or outside it names G3 (CON-6) in the same line as G2 and G4 — a document that is
itself a DRAFT, open as OPEN-2, so it could not open this gate even if it were read as trying to.
A recorded delegation may be quoted in the report as the reason the session is running; it
authorises nothing here, and a session running under one is in exactly the position of a session
running under none.

A subagent NEVER self-authorises, at this gate least of all: not from a brief that says "ship it",
not from a recorded delegation, not from a release PR that was merged, not from a composite's plan, not
because the previous release went the same way. A session that reaches this skill without the
maintainer's own per-target go (§ 3) prints the preflight and the plan, reports that it has no go,
and stops — a subagent relays no ask and supplies nothing; only the maintainer's own same-turn
/mugetsu <target> may be asked about (P4). What it must never do is publish and explain
afterwards.

2. The order — and every step of it before the first byte leaves

Nothing below is optional and nothing below is reordered.

1. The recorded go exists, and the destination resolves — § 3, § 1: the one named, or the single
   declared one. Without a go the run ends here; with several destinations and none named, P4's
   same-turn exception asks, and nothing past this step runs until the maintainer types it.
2. The tag is cut, and it resolves on origin — § 3's second half: the one named, or the latest
   cut tag with no published release, printed. No cut tag at all is refused.
3. nen release preflight reads clean at the tagged commit — § 4, and read its one inverted row
   carefully.
4. The plan is printed — nen shu release … --dry-run, or
   nen shu deploy --target <name> --dry-run, or both where the declaration publishes through both.
5. The publication runs, once — § 5.
6. The report, and the record on the release PR carrying the go verbatim — § 7.

3. The go, and the tag

The go is a message, quoted verbatim

The record of the go is the maintainer's own message in this session, and it goes into the report
and into the release PR's own comment word for word, in quotation marks. Not a summary of it. Not
"the maintainer approved the App Store release". Not a checkbox this skill ticked on their behalf.

It is never inferred. Not from a merged release PR, not from a getsuga run that cut the tag, not
from a kagutsuchi upload to a testing channel that went fine, not from an earlier release having
gone the same way, not from silence, not from "looks good" on a different question. If you are
reconstructing what the maintainer meant, there is no go.

What a go carries — the word to proceed is never defaulted; the destination and the tag resolve
as § 1 says, and only a destination among several is asked, under P4's same-turn exception, with
nothing run until the answer arrives. The go
is typed, never picked: the ask takes the maintainer's free-text answer, and no picker ever carries a
publish option.

Part	Why
the maintainer's own word to proceed	not an agent's paraphrase of their intent — the one part that is never defaulted
the destination, by the name the declaration gives it — or the single declared one (§ 1, ruling of 2026-09-28)	a go for one store is not a go for another; several declared and none named is the one ask
the version or tag being published — or the latest cut tag with no published release (§ 1)	a go is for a build, not for a repository; the resolved tag is printed and quoted beside the go

Nothing in nen records this (§ Residue). nen stop --notified writes .nen/last-stop.json for the
bell and is not a record of an authorization. The quote is the record.

The tag it means is getsuga's RELEASE tag, and no other species

From 2026-09-18, as corrected on 2026-09-19, TWO skills can put a tag on origin, not one:
`/kagutsuchi` § 4a cuts dist/<target>/… after an upload that
succeeded, and `/getsuga` cuts the release tag. (
`/susanoo` § 5a cuts nothing — it only names the identity the coming tag
will carry.) Only getsuga's satisfies anything here. A distribution tag records where a binary
went; it authorises nothing, it is not a release, and it never satisfies § 2's precondition 2 or
§ 4's preflight row — which were both written when only getsuga could put a name on origin
and read as name-existence checks for that reason.

The go names the version, so the human is the discriminator in practice. This clause is what makes it
so by rule as well.

The advance go — the one go typed before the tag exists

Maintainer's ruling, 2026-09-26 (`docs/ROSTER.md` § Rulings of 2026-09-26/27/28): a futon invocation whose then chain
names this skill — /futon <repo>@<selector> then getsuga+mugetsu[@<target>] — is itself the
go, given in advance of the tag. It is the one way a composite reaches this skill, and it is
narrower than the ordinary go on every axis. This is the canonical definition (recorded in `docs/ROSTER.md` § Rulings of 2026-09-26/27/28); `futon`
§ 8, `getsuga` § 1, `kagutsuchi` § 1, `aka`
§ 0 and `mukai` § 1 cite it and restate none of it. By the ruling of
2026-09-28 (b) it is wider than this skill: a typed chain step is the maintainer's own call for
any skill whose call is the maintainer's — aka, mukai, kagutsuchi, this one — still never
prompted for and never proposed; the chain is the call.

• Record. The maintainer's typed futon invocation, quoted verbatim, is the go: their own words,
  never inferred, never picked. An invocation Kurapika composed, a picker option, a recorded delegation
  or a brief is not one.
• Binding. It covers the tag this run's getsuga step cuts, or — with no getsuga step ahead of
  it, or one that cut nothing — the latest cut tag with no published release, resolved when this
  step runs (§ 1, ruling of 2026-09-28 (a)); either way the version is printed and quoted beside the
  go. The destination is the one the step names (mugetsu@<target>) or, with none, the repository's
  single declared one; two or more declared and none named → asked as free text
  (missing-maintainer-choice), never picked.
• Single use. One go, one target, once. It lapses if the run ends, halts or stops at a G5
  before this step is reached (a delivery merge is en § 5's, never a stop), or if a getsuga step
  ahead of it cut a tag and the tag in hand is not that one. Never carried to another run.
• Order. This step runs only after its tag exists on origin, with every precondition of § 2 and
  § 4 still holding — nen release preflight green, the plan printed. Delivery merges stay the
  maintainer's (G2/G4): the chain waits at each of those prompts and merges none. The one PR the
  chain does not wait for is getsuga's own release-proposal PR, which getsuga merges itself through
  its § 3a (the same rulings section).
• Repository kind — this skill only. Allowed only on a repository of kind process or
  library (`WORKFLOW.md` § Repository kinds defines the three).
  The policy is data, not prose: nen/workflow.json → futon.advanceGo (nen's built-in default
  where none is declared, from nen v0.15.1), read by nen parse futon, which annotates
  the step with gate: {allowed, kind, reason, source} from nen repo classify's own verdict —
  unknown fails closed — and prints a refused: mugetsu (<reason>) [<source>] line that
  `futon` § 8 relays verbatim at its parse echo; the maintainer gives the go
  the ordinary way once the tag is cut, and the rest of the chain still runs.

Still: no agent proposes it, no picker carries a publish option, and G3 is satisfied by the
maintainer's typed word — only the human authorises a release, and here only the human did, in
advance.

A go with no tag is refused

The tag is cut first, by `/getsuga`, and it resolves on origin.
A publication with no tag is a build nobody can point at afterwards: latest in the registry, the
CHANGELOG section, the fan-out ledger and the release record all name a tag, and CON-14 forbids
writing any of them for a tag that does not resolve.

So: no cut tag at all → refuse, name /getsuga as the phase that cuts it, and stop. With
no version typed the tag it means is § 1's — the latest cut tag with no published release — and an
advance go bound to a getsuga step ahead of it waits for that cut and means that tag and no other.
Do not cut it here
— that is Kurapika's duty in that skill (CON-33(b)/CON-41), with its own preconditions, its own
release PR and its own G4 — and never publish "and tag afterwards".

4. nen release preflight — read it, and read the row that inverts

export GH_TOKEN=$(gh auth token)
nen --repo <path> release preflight \
  --repo-slug <owner/name> --tag <vX.Y.Z> --range <vPrev>..<the tagged commit> \
  --changelog <path to CHANGELOG.md at that commit> --owner-repo <owner/name> \
  --critical-issues <n,n or ''> --live-chores-from <path>

This is a read. It reaches GitHub through gh variable get and git ls-remote origin and changes
nothing. --critical-issues and --live-chores-from are gathered by the caller exactly as
`/getsuga` § 2 specifies — that skill is the authority for how, and this
one does not restate it. Omitting either flag fails its row rather than skipping it: verified
live, "FAIL open critical issues -- not supplied -- not checked (pass --critical-issues, or
--critical-issues '' to assert none)" (docs/ab/mugetsu.md § 2.2).

The one row that must FAIL, and why the exit code is not the verdict

preflight is a pre-cut table and mugetsu runs after the cut. Its sixth row asserts the tag
does not already exist — which, at publication time, is precisely what must be false. Verified
live at nen 0.3.0 (docs/ab/mugetsu.md § 2.3): against an existing tag the row reads
FAIL tag does not already exist -- 'v0.4.0' already exists -- re-tagging is never the fix, and
the table exits 1.

So mugetsu's green is not exit 0. It is: every row ok, except tag does not already exist,
which must read FAIL … already exists — and nothing else failing. Read the rows, never the
exit code alone. An exit 1 with two failing rows and an exit 1 with that one failing row are
opposite verdicts.

And that FAIL is worth more than a pass would be, because the row reads origin, not this
checkout. Verified live: a tag created locally only reports ok … clear
(docs/ab/mugetsu.md § 2.4). So the row failing is positive evidence that the tag is on the remote
and resolves for consumers — the § 3 requirement, proved by the same call.

Any other failing row is a stop, whichever it is: an active RELEASE_HOLD, an open critical, a
live CON-36 chore, an uncollated changelog.d/, an unreconciled CON-33(c). Relay the whole table
as printed — the verb reports every row and never stops at the first — and stop with
`/jutaisho` § 4's rendering: nen stop --who kurapika --gate G3 <efforts.md>, the report link, the options with ⭐ on the recommended decision — the report linked, never an option (Crazy Slots), the question through the surface's
own picker. A held release is honoured as printed; getsuga § 2 carries the RELEASE_HOLD
truthiness rules and this skill does not restate them.

5. The publication — and the flag that is not there

A repository publishes through its declaration, in one of two shapes, and which one is a fact about
the declaration, never a preference.

5a. nen shu release — and it has no --run gate

nen shu release --repo <path> [--lane <lane>] --dry-run      # the plan. ALWAYS first.
nen shu release --repo <path> [--lane <lane>]                # THIS PUBLISHES. There is no --run.

⚠️ The bare form is the publication. Verified live at nen 0.3.0
(docs/ab/mugetsu.md § 2.5): nen shu release --run is refused at exit 2 — "--run is not read
by 'shu release'. A flag accepted and ignored is worse than one refused" — and the bare line
spawns the declared publication step at exit 0. shu deploy's two-flag discipline does
not exist on this verb.

Three rules follow, and they are this skill's alone because nothing enforces them:

1. --dry-run first, every single time, and paste that would run: argv into the reply before
   anything else happens.
2. The bare line is typed only after § 3's go is in hand and quoted. Not to "see what happens",
   not as part of a survey of a repository's verbs, not inside a loop, and never by a skill other
   than this one.
3. Never type it speculatively on an unfamiliar repository. On a repository whose release row
   you have not read, the dry run is the only safe invocation.

shu release takes no --target — verified live, exit 2 with the same "a flag accepted and
ignored" refusal (docs/ab/mugetsu.md § 2.5). So the verb has no per-destination vocabulary at
all: "one target per call" is this skill's discipline, and where a repository publishes to several
destinations it declares them as separate lanes (each with its own release row) or as deploy
targets — § 5b. A lane whose release row publishes to more than one destination in one run cannot
be published per target through this verb, and that is a declaration to fix at the declaration gate (G4 in a canon repository, G2 in a consumer one), not a run to
improvise around.

5b. nen shu deploy --target <production target> --run

Where the production destination is a project.targets key, the publication is deploy's two-flag
form and every mechanic is `/kagutsuchi`'s — the plan first, the
refusal order, the credential discipline, the seats. This skill restates none of it; read it there.
The differences are the two that make it G3:

• The --run is spoken only after § 3's go, per target, quoted in the report and in the release
  comment.
• kagutsuchi refuses a production target and this skill is the one that does not. The two
  skills are the same verb split by destination, and the split is the gate.

Verified live at nen 0.3.0 against the fixture (docs/ab/mugetsu.md § 2.6): the plan, the asserted
requiresEnv, then --run spawning exactly the composed argv, exit 0.

A declaration may use both — a store upload through release and a production web deploy through
deploy. Run each one's plan, then each one's publication, in the order the declaration and the go
name, saying which is which. Still one target per call.

6. The exit table

claude/agents/kurapika.md § The shu verbs is the authority.

Exit	Fact	Reaction
0	the plan rendered, or the publication ran	§ 7
1	the publication tool ran and failed	relay its output and the failing step. Say what state the destination is in, or that you do not know — a half-completed store submission is the one failure that is not local, and the maintainer needs to know before anyone retries. Never retry without a fresh go
2	usage, or an unsatisfied precondition (the lane's, or a requiresEnv name)	the plan still prints with the failing rows marked FAIL. Relay it whole, satisfy the fact, and re-run under the same go only if it is the same target and the same build
3	unsupported host	G5. Publishing from a machine the declaration excludes is not a thing to route around. Name the hosts and stop
4	a seat — the lane declares no release, or the target declares unsupported	quote it verbatim and stop. This repository does not publish through nen, and the declaration's own words are the whole report. Hatsu's own row used to be the worked example here and no longer is: the maintainer's ruling of 2026-09-19 retired that seat, because a repository whose product is the process must declare a real row — a seat left this skill with nothing to execute while releases were published by hand. An example of a genuine seat is a lane that truly has no destination, and its own words remain the whole report
5	the declared program could not be started	nen shu tools --repo <path> and relay the remedy — reading `/susanoo` § 7 first. nen never synthesises signing material, and neither does this skill: a missing notarization or store credential ends the run

7. Report, and the record on the release PR

One block, then stop:

• The go, quoted verbatim, with who said it and when.

• The tag, and that it resolves on origin (§ 4's inverted row is the evidence).

• The preflight table as printed, whole, including the inverted row read as green.

• The plan's composed argv, copied out of the --dry-run report, not re-typed.

• What ran, each step's own exit code and nen's, and which destination it reached.

• published or not published, in those words.

• The host re-pin, when the repository just published IS this session's nen (zheref/hatsu#90):
  the target's origin (nen repo resolve --repo <path> --from <path>) resolves to the plugin's
  nen/contract.json → dependency.source, and § 5 has just attached the assets. Then, before any
  further nen invocation, `ten` § 2b's verb and nothing else, for the tag this
  run published, read back from the release § 5 wrote — never a tag listing; a <newTag> that is not
  that release is a halt, not a fallback:

  d="$(mktemp -d)"; curl -fsSL <dependency.bootstrap.url with <newTag> in place of the pinned ref> -o "$d/nen-bootstrap.sh"
  out="$(nen bootstrap --ref <newTag> --source <dependency.source> --script "$d/nen-bootstrap.sh")" || { rc=$?; repin="FAILED: rc $rc"; }   # ten § 2b's verb; NOT ten § 3's halt
  verified="${out##*$'\n'}"; { [ -z "${rc:-}" ] && [ -x "$verified" ]; } || repin="${repin:-FAILED: not executable}"   # BEFORE any ln or PATH
  [ -n "${repin:-}" ] || { mkdir -p "$d/bin" && ln -sfn "$verified" "$d/bin/nen" && export PATH="$d/bin:$PATH"; }   # (b) this session

  A non-zero exit is never hidden — and never a halt. ten § 3 is the session-start supply-chain
  halt; here § 5 has already published, so a failed re-pin links nothing, keeps the pre-release
  binary the session came in with on PATH (said), and goes into the report as host nen: <version> on PATH; re-pin FAILED: rc <n> — § 6's release-PR comment and the publication report still go out,
  and the next session's ten § 2b meets the new pin or halts there. A failed re-pin and a skipped
  one are two different lines (ten § 2: neither path hides its exit code).

  The script at <newTag> is fetched outside the contract's pin — the one call site where it is —
  and the binary it produces is still checksum-verified by the verb; the contract's pin follows in
  the repin PR (ten § 1), never here. Assets not attached, or the verb refusing the ref: stay on
  the current binary and say so — host nen: <version> on PATH, pre-release; re-pin deferred: <reason>. The report line names the version now on PATH — host nen: <version> on PATH (re-pinned from <old>) — and its absence is the signal that the step was skipped. ten § 2's
  (a), the ~/.local/bin/nen link, stays the maintainer's word. Applies to nen and nothing else.

The same quote goes onto the release PR or the tracking issue — through the one verb that owns a
caller-written comment, never a raw gh:

nen issue comment --target <owner/name> --issue <the release PR or issue number> --body-file <path>

A pull request is an issue to this verb, which is why there is no nen pr comment and none is
needed (nen pr --help lists eight verbs and no comment among them; nen issue comment is "the
general primitive every other verb here lacked, so a mechanized choreography no longer has to drop
back to a hand-run 'gh issue comment' for the one step written in a human's own words"). Use
--body-file rather than --body — a go quoted verbatim carries newlines and may begin with a
character the parser would read as a flag. The comment is the durable record; the session's
transcript is not.

Re-render the turn report before stopping — `/spiritual-message` § 5's turn
variant, at the same address, with the publication written into 01 Accomplished.

Then say nothing about what is available next. Not another target, not a promotion, not a next
version. The next go is the maintainer's.

Residue

1. Nothing records the go. No nen verb writes "the maintainer authorised production for
   v1.2.0", and .nen/last-stop.json is a bell marker, not an authorization ledger. The quote in
   § 7 is the record, written by hand into the report and the comment.
2. nen shu release has no --run gate (§ 5a, verified live) — so the whole "show it before you
   do it" discipline on the publication verb is this skill's, unenforced by anything. The one
   mechanical helper is --dry-run, and typing it is a rule, not a guard.
3. nen shu release has no --target (verified live, exit 2). "One target per call" is this
   skill's discipline; per-destination publication has to be modelled as lanes or as deploy
   targets in the declaration.
4. release preflight's tag row inverts after the cut (§ 4, verified live) — so the pass/fail
   reading is by hand, off the rows, and the exit code alone is never the verdict. There is no
   --expect-tag-exists or post-cut mode at this pin.
5. Nothing marks a destination as production. project.targets.<name> carries no such field
   (`/kagutsuchi` § Residue 1), so the split between that skill and
   this one is read out of why prose by hand.
6. What state a failed publication left the destination in. nen reports the tool's own exit code
   and never queries the far end. Saying so is by hand, and it is the sentence § 6's exit 1 row
   requires.
7. A per-run log file. A .nen/logs/ transcript is not in this release (zheref/nen#91) — the
   report is the only record of what a publication printed.

Authority

• Permitted, and only on the maintainer's recorded per-target go, with the tag cut and resolving:
  read nen release preflight; print the publication plan; run the declared publication once —
  nen shu release for that lane, and/or nen shu deploy --target <that target> --run; write the
  report and the release PR's comment carrying the go verbatim.
• Not permitted: cutting, moving or deleting a tag (`/getsuga` cuts;
  nothing moves one); merging main; opening or merging a PR; a G1 mode label; publishing a second
  target, a second build or a second time on one go; writing latest or a dated CHANGELOG section
  for a tag that does not resolve (CON-14).
• G3 is the maintainer's (CON-6). This skill executes a recorded go — the ordinary one or § 3's
  advance go — it never grants one, never infers one, and never treats its own reasoning as one.
• The go is one publication wide and ends when this run ends. It is the maintainer's own message
  and nothing else — a delegation does not stand in for it, because G3 is not delegable (§ 1).

Hard limits

• Never runs unasked, and never prompts for itself — no agent, skill, report, bell, stop option
  or PR body proposes /mugetsu (§ 1).
• Never runs from a composite on the composite's authority. getsuga, en, mukai and ren
  never call it, on any path; futon reaches it only as a typed then step on § 3's advance go, on a
  repository of kind process or library, and never under its delegation.
• Never treats a delegation as the go — G3 is not delegable, so a session running under one has
  no more authority here than a session running under none — and never publishes and explains
  afterwards (§ 1).
• Never infers the go. A merged release PR, a cut tag, a clean preflight, a successful staging
  upload and a previous release are each, and together, not a go (§ 3).
• Never publishes without a tag that resolves on origin, and never cuts one here to proceed
  (§ 3).
• Never reads release preflight's exit code as the verdict after a cut — the tag row inverts,
  and the rows are what is read (§ 4).
• Never types nen shu release bare before the dry run and before the quoted go — that verb has
  no --run gate and the bare line publishes (§ 5a).
• Never publishes more than one target per call, and never treats one target's go as another's.
• Never retries a failed publication without a fresh go, and never reports a destination's state
  it did not observe (§ 6).
• Never synthesises, forges or reads signing material or a store credential — a missing one ends
  the run (§ 6).
• Never paraphrases the go in the report or the comment. Verbatim, in quotation marks, or it does
  not go in.