Shibari — the work becomes a request for attention

Nature: Manipulator. Turn everything the run proved into one body a reviewer can act on, open the
PR on it, and hand it to `en`; the authoring nature is named inside the body, in
Why, never adopted here. Shibari is step 8 of `mukai`, the last step that
writes anything and the only one writing to GitHub, and it proves nothing of its own: a
section with no fact behind it says so. The landing report is rendered after this step, from what is on the PR.

0. Standalone entry

Already total (`docs/STANDALONE-ENTRY.md` § 4): cold entry adds
P1 and P2, carrying the one precondition a cold call can fail — the branch must already be
pushed. State the branch, whether it is published and how many commits are unpushed; a PR would
omit them, so stop and name `aka`, never pushing for the maintainer. Evidence that does not exist because hanten, kotoamatsukami or
byakugan did not run is stated unavailable, with why — never a plausible table.

1. Invocation and authority

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

/shibari

No arguments, so no nen parse: the branch is the input, the base comes from
the workflow file (§ 2), the issue from the branch's own commits. The maintainer's /mukai
or /shibari call is this run's authorization: opening a PR is a human call
(`docs/WORKFLOW.md` § 4) no agent proposes and no composite reaches
unasked, and that call covers the evidence mechanism's publish step, not asked again per scene — in
Hatsu's terms (zheref/hatsu#101): the harness's own permission classifier is a separate layer reading
-y as a blind apply, so the publish command carries -y only because its own confirmation would block a
non-interactive tool, this run says before the call what it publishes and that the harness may ask once,
and where the consumer has not declared the grant (on Claude Code, a tracked .claude/settings.json allow
row for that one script, added by the maintainer — `mukai` § 1) the stop there is
expected and named in § 5's line, never a G5.
One call, one PR — a run that finds two efforts opens neither, names
`jujisho` and stops.

2. The parameters, defaults stated

Key	File	Used for	Default
branch.base	nen/workflow.json	the PR's base, and the origin/<base>...HEAD range every section is computed over	main
commits.allowedAttributionTrailers	nen/workflow.json	the truthful canonical persona/plane trailer	Hatsu-Agent, Akatsuki-Agent
coverage.*	nen/workflow.json	the band the checklist quotes from byakugan	80/85/90
project.evidence.globs/.scene/.mechanism	nen/contract.json	the UZF-26 rows, scene naming, and which mechanism the stack is on	no globs is the no-evidence case, stated in the body; {suite}-{scene}; the committed-path mechanism, never the mirror

• A missing configuration item is asked for and set up inline (missing-configuration;
  `WORKFLOW.md` § 4 Ask, set up, continue); both files are read and
  validated as `PROCESS.md` § Invocation and parsing says.
• The range is origin/<branch.base>...HEAD, after git -C <path> fetch origin <branch.base> —
  nothing fast-forwards local main, and nen gate derive and
  nen changelog fragment-required take --files, so a wrong set gives a confident wrong answer.
• nen shu evidence --repo <path> --base <ref> reads project.evidence, but the rows come from
  mukai step 7 and shibari re-uses them, never re-derives them.

3. The body

A published injected attribution trailer (`aka` § 7, zheref/hatsu#66) is
disclosed as its own ## Completion checklist line — injected attribution trailer: <sha> <key>, published before the switch; not rewritten — not in the ledger.

The body is `templates/pr-body.md`, filled — its parts in order,
the optional ones as its own comments say, § 4's three checks commented at its top. The target's own
template governs the section names where it has one, and the UZF-26 evidence shape is
`docs/WORKFLOW.md` § The UZF-26 evidence shape. Every screenshot is a
cell of that section's table — states as named columns, variants as labelled rows, one fixed-width
labelled image per cell — and "$hatsu_root/scripts/pr_body_evidence_check.sh" --body <file> passes before the
body is written, on the first write and on every rewrite after a review, which re-renders the whole
Evidence section and never appends below it.

Associated issues — body AND Development (ruling 2026-09-12), which shibari enforces:

• Every issue the PR addresses appears in both, on single-issue and combined PRs, at creation,
  at every scope amendment and at handover; the body table carries each canonical URL, the scope this
  PR implements, and whether merging completes it or delivers part, with prerequisites listed
  separately and a PR with no associated issue saying so.
• After opening or editing, compare the expected set against live Development associations — a
  body mention alone is not proof. A separate
  supported closing clause per issue creates it on a default-branch PR; otherwise use GitHub's own
  linking interface and verify. Never invent a Nen link verb; never assume Part of #N links.
  Non-default bases, cross-repository links and the UI's link-count limit need live checks.
• Linking and completion are different claims: never mislabel partial work as complete to tidy the
  sidebar, never change auto-close settings, preserve a partial issue's remaining scope, and report an
  auto-close conflict for the maintainer's disposition before merge.

Agent attribution is the final heading, exactly as
`docs/AGENT-ATTRIBUTION.md` specifies: every and only the
agents that actually participated, never one inferred from the branch, a reviewer request or a model
label.

4. Open it, check it, write it back

git -C <path> fetch origin <branch>
git -C <path> rev-parse HEAD refs/remotes/origin/<branch>     # the two MUST be equal
nen repo resolve --repo <path> --from <path>                  # -> <owner>/<name> (<CODE>)
nen ref format --code <CODE> --kind PR --number <n>
nen pr open --target <owner/name> --base <branch.base> --title-file <abs> --body-file <abs> \
  [--head <branch>] [--draft] [--dry-run] [--json]   # title-file: the one commit's subject

nen pr body-check --body-from <abs path> --requirements-from <path>
nen changelog fragment-required --spec-paths "CONSTITUTION.md,handbooks/,nen/,schemas/,agents/,.github/workflows/" \
  --fragment-dir changelog.d --files <the changed paths> --head-changelog <path to CHANGELOG.md> \
  [--body-from <abs path>]
nen pr edit-body --target <owner/name> --pr <n> --body-file <abs path> [--dry-run] [--json]

• The two refs must be equal; if not, the run stops and says which is ahead. pr open refuses a head that is not on the remote at
  exit 2 and exits 1 naming an open PR for the branch; it opens once, draft or ready
  being the repository's convention.
• body-check reports every requirement; exit 1 is a finding to fix.
• fragment-required has four verdicts — not-applicable, required (exit 1),
  fragment-present, and opt-out where --body-from carries a no CHANGELOG entry: <reason> line.
  Keep both nen/ and schemas/; a missing --head-changelog is exit 2; fragment-present needs the fragment on disk at head as well as in --files.
• The gate is derived as `docs/WORKFLOW.md` § Gate derivation
  says, and the body names it as a FORECAST, never a status — a PR just opened is not ready.
  Shibari derives the gate and never labels one: a label is a readiness
  claim, and readiness is nen pr ready's verdict inside `en`, after this run (in zheref/hatsu, pr-readiness.yml publishes it as the readiness check; shibari never
  writes that either).
• The body is written back only after all three checks have run. The create is the first write and
  every later revision is an edit: nen pr edit-body replaces the body outright and certifies
  the number before any write, refusing a 404/410. A relative --body-file resolves against
  --repo's root, so the body is written to an absolute path.

5. Reviewers, and the hand to en

nen pr request-reviews --target <owner/name> --pr <n> --add-reviewers <a,b> [--add-bots <id,...>]

The reviewer-round policy is `sharingan` § 6's — one Copilot round after
`hanten` settles, never before — and this skill makes only the first request.
The request's mechanics are PROCESS.md § Reviewer rounds and review
threads: the maintainer's token, Copilot through --add-bots <node id>, and success read from
the mutation's own response, never from the ids sent.

Then one line, and stop: the notation, the base, the gate forecast, whether the three checks
passed, the evidence mechanism — and, where the harness classifier stopped its publish step, the field
permission stop: expected — <consumer> declares no allow row for <script> naming the missing grant
(§ 1; zheref/hatsu#101), never a G5 — who was requested, and — from mukai — its offer of `en` on the PR
(En has it already only under mukai.autoEn). No nen stop banner — opening a PR is not a gate event, and
en's own `jutaisho` step rings at Ready.

6. Residue, authority and hard limits

Named raw calls: `PROCESS.md` § Residue and owned dependencies.

• Permitted, only on the maintainer's own /mukai or /shibari call: read the working
  copy and its history; write the body file; open one PR against branch.base from the last
  pushed commit; edit that PR's body; request reviewers; run the target's own declared
  evidence-publish step on public-mirror. The delegation is one run wide.
• Not permitted: any merge, label, review vote or commit; any push, force-push or --no-verify,
  even to satisfy its own precondition; a second PR, or one for a branch whose HEAD is ahead of
  origin/<branch>; touching a PR this run did not open.
• Never opens a PR without # What this changes for you, ## How to verify, the final
  ## Agent attribution, and the changelog.d/ fragment where one is owed — all decided by verb.
• Never writes a section with no fact behind it, and never ticks a completion box by assertion.
• Never stages a capture that is not one of the branch's re-recorded test artifacts, and never
  treats an untracked evidence gap as a sanctioned incompleteness.
• Never passes a body as an inline --body string, reports a reviewer as requested when the call
  no-opped, or reports a missing Development link as present.
• Never fires the nen stop banner, and never presents by-hand git/gh as a verb's output.