zheref
@zheref
Public Skills
ren
by zheref
Run one request end to end as a turn — warm up on the first turn, author the change the request asks for, verify and commit it locally, launch the app, publish the report, ring the bell — and then wait for the next request. Use when the maintainer invokes hatsu:ren <request>, or simply asks for work in a repository where the turn loop is how work is done. Ren composes the six atomic skills by name and restates none of their protocol; it never pushes, never opens a pull request, and ends only when the maintainer calls hatsu:aka or hatsu:tensho.
shibari
by zheref
Compose the pull request body from templates/pr-body.md and open the PR — the UZF-26 evidence table, the completion checklist, every associated issue and the agent-attribution ledger — then check it by verb and return the PR to mukai, which offers it to hatsu:en (or starts En under mukai.autoEn). Use when hatsu:mukai reaches its eighth step, or when the maintainer invokes hatsu:shibari directly. It opens exactly one PR, from the last pushed commit, against the workflow's base; it derives the gate but never labels one, requests reviewers, and never merges.
mukai
by zheref
Take a pushed branch through catch-up, review, impacted tests, coverage and evidence to one open PR, render its landing report, then end by OFFERING to start En on the PR — one line naming hatsu:en on #<N>, never started silently — or, when nen/workflow.json → mukai.autoEn is true (absent means false), by starting En immediately in the same turn. En owns the capped current-head readiness loop through required CI and review. Mukai owns kotoamatsukami's unit/UI/integration tests and byakugan's coverage capture and gating. Gyo is linting on the Ren loop. Mukai gains no squash, first-publish, merge, or review-vote authority from nested phases.
murasaki
by zheref
Bring an already-published branch up to date with its base, rerun the shared iteration checks, and before pushing any source/test change return to the caller so kotoamatsukami can refresh impacted tests and byakugan can recapture coverage. Murasaki composes ao; it never independently owns tests, coverage, squashes, force-pushes, first-publishes, or opens a PR.
getsuga
by zheref
Cut a release tag locally, end to end — preconditions, one folded release-proposal PR merged inside § 3a's bounds (or by the maintainer where they do not hold), the post-merge tag, then the CON-22 fan-out. Use when the maintainer invokes hatsu:getsuga [<hash branch-name main last-commit checkout>], or asks to cut a tag, cut a release, or ship a version. The cut point is never required: with no token it is origin/<branch.base> from nen/workflow.json (plain main when none is declared), stated with its source in the first line; a typed token always overrides, and a version-shaped token is read as the tag name. An off-main target is driven to main first, and susanoo builds the release unit. Merges exactly one PR itself — its own release-proposal PR, when its diff is the release unit only and CON-32 reads Ready, through the repository's own protection (the maintainer's ruling of 2026-09-26) — and never a delivery PR; never publishes a release — publication is mugetsu's, per target, at G3 — and never tags a commit unreachable from the configured trunk, origin/<branch.base>.
en
by zheref
Take one open pull request from the moment it opens to verified readiness at its human G2/G4 gate, under a mandatory acting-cycle cap — the landing report, fresh current-head observation, Sharingan remediation, catch-up when behind, and the bell only at Ready. Use when hatsu:mukai hands over its PR, or when the maintainer invokes hatsu:en on #<N> for a PR that is already open. Pending CI or review keeps the run active; quiet polls spend no cycle. En never merges and never casts a review vote. After this run completes, the regular pipeline's next phase is hatsu:third-hand — En does not own it.
backlog-loop
by zheref
Drive a target repository's backlog to zero open actionable issues, in severity order, as gate-ready PRs. Use when the maintainer asks to work the backlog, clear open issues, run the loop, or keep a repo current. Kurapika triages, sequences build and sharingan across at most two efforts, cuts tags and runs the fan-out at severity-batch boundaries, and renders the per-cycle status board as a Rikugan. Never merges main; G2/G4/G3 stay the maintainer's.
kagutsuchi
by zheref
Send a build to a declared NON-PRODUCTION destination — the internal channel, the testers' track, the preview environment — by running the repository's own deploy row through nen shu deploy --target <name> --run. Use ONLY when the maintainer invokes hatsu:kagutsuchi <target> or asks in their own words to upload this to a named destination. The plan is printed always, sending happens only on that call naming that target — typed by name, or as a futon then step on the advance go mugetsu § 3 defines — no composite calls it on its own authority and no agent proposes it. Production and the stores are hatsu:mugetsu at G3, never this skill.
ao
by zheref
Bring the branch up to date with its base — rebase when nothing has been published, merge when it has, resolve the mechanical conflicts, and stop at G5 with both sides shown for a semantic one. Use when the maintainer invokes hatsu:ao [from <base>], asks to pull main in, catch the branch up, or rebase onto main, or whenever hatsu:aka, hatsu:murasaki or hatsu:en needs the branch current. Kurapika classifies every conflicted path before touching one and never picks a side on a conflict of meaning. Never pushes, never force-pushes, never rewrites a commit that is already on the remote.
breath
by zheref
Warm the local working copy once per effort — classify where the checkout sits, check the host toolchain, fast-forward the trunk and cut this effort's branch from its fresh tip, then prove the declared iteration checks pass on that tip, because a base that does not build is a G5 stop taken before any of the change is authored. Runs as the first turn of an effort inside ren; invoke it by name only to re-warm a drifted checkout. Never discards work it has not shown you, never commits, never pushes.
futon
by zheref
Work one selector of a repo's backlog — a severity band or one exact label — into PRs with an actor behind them, then run what follows then. Use when the maintainer invokes hatsu:futon <repo>@<severity[+] label> [then tag tag+fanout <skill>@<target> <prose>], or asks to work a band or a label. Kurapika scopes backlog-loop's engine to one selector; every PR is his own (Hatsu carries no CI plane), so done means CON-32 Ready and a per-PR merge prompt. Nothing after then runs before that; a typed then step is the maintainer's own call for the skill it names (the advance go, mugetsu § 3). Never merges main, never publishes a release itself.
build
by zheref
Take one issue from wherever it sits to a delivery PR standing ready at its human gate. Use when the maintainer invokes hatsu:build #<issue>, or asks to build, start, release or deliver an issue. Kurapika confirms the mode, builds the issue himself — Hatsu holds no CI plane to route it to — and drives the resulting PR to CON-32 readiness, escalating a stuck effort to G5. Never merges, never applies a G1 mode label.
gyo
by zheref
Lint the tree on every Ren turn — the named Hatsu process for the declared lint verb. Breath proves it on the fresh tip, rasengan may run it as authoring feedback, kokusen must run it over the finished tree before it commits, and aka runs it before squash and again after catch-up if the tree moved. It never measures coverage and never runs tests.
byakugan
by zheref
Capture instrumented coverage and measure touched-file coverage at mukai, independently of unit, UI and integration tests. Kotoamatsukami runs those suites; gyo is linting. The declared coverage row may extract or parse a matching capture but must not rerun tests. Each test remediation invalidates evidence and returns through kokusen and kotoamatsukami before recapture and remeasurement.
great-hiker
by zheref
Author and maintain canon prose and canon machinery in the governance and process repositories, and guarantee it lands on every supported surface with that surface's best capabilities (skills, personas, hooks, allowlists, rules files, model config). It is the writer hatsu:tenkai and the warm-up install from. Use when the maintainer invokes hatsu:great-hiker <request> [--effort low medium high] to change canon, or hatsu:great-hiker evolve [<surface>] to diff a surface's evolution guide against its cited official docs and file one Netero-shaped issue per drifted surface. Never edits surfaces/ by hand, never claims a capability without the fetched line quoted, never merges.
third-hand
by zheref
Harvest one sitting's process friction as Netero — propose 0–3 folded issues, file only what the maintainer picks, then end the session. Use after En has completed on the regular Kurapika pipeline, or when the maintainer invokes hatsu:third-hand while wrapping. Never merges, never implements the filed work. Not a step of En.
amenotejikara
by zheref
Swap which worktree the maintainer's core checkout holds, and swap back — list every checkout of the project with its branch, dirt and distance from the base, bring one worktree's committed tree into core so Xcode (or any IDE opened on core) and hatsu:amaterasu build and debug exactly that, and return core to where it started with its own uncommitted work restored. Use when the maintainer invokes hatsu:amenotejikara [list <worktree branch> [--take] return status], or asks to swap to a worktree, see what a worktree holds, debug a worktree from Xcode, or put core back. Core's work is parked in a pinned commit, never stashed; nothing is discarded, pushed or committed on anyone's behalf.
backlog-state
by zheref
Render the current backlog as one gate-oriented table — every open issue with its associated PRs, for one repo or all of them, showing the human gate each item sits at, what it needs next, and which session is driving it. Use when the maintainer asks what the state is, what needs them, what is at a gate, or invokes hatsu:backlog-state <repo all>@<G1 G1-M G2 G3 G4 G5 all>. Strictly read-only — it never labels, merges, pushes, comments or opens anything.
file
by zheref
File one well-formed, correctly-labelled, non-duplicate issue — reconciling it against the open backlog first. Use when the maintainer invokes hatsu:file <problem> <repo> or a bare hatsu:file (which files what the session has just been discussing), or asks to file, open, log or raise an issue. Also execute the shared discovery protocol when authorized work exposes a durable workflow, machinery, or owner gap. Process-chairman findings — constitution, canon prose, machinery enhancement, duration, redundancy, autonomy gaps, deterministic jobs still done by hand, missing toolchain — are Netero's completeness contract (claude/agents/netero.md; Codex: the Netero section of AGENTS.md): every declared classifying label, observable acceptance criteria, and cross-references for deployment, fan-out and provisioning. Kurapika searches for duplicates to amend, near-neighbours to fold into, and issues this supersedes before writing.
black-voice
by zheref
Validate a delivered feature after its PR merges — resolve the PR and the issues it closed, take their acceptance criteria verbatim, raise Shalnark once to drive every one of them through ephemeral automated UI tests in the repository's own pinned tooling, and publish pass / fail / not-testable per criterion as a Rikugan page. Use when the maintainer invokes hatsu:black-voice [#<PR>], or asks for the merged feature to be validated against what was asked for. It is never automatic and never called from a composite; it fixes nothing, merges nothing, and files a failure only on the maintainer's word.
aka
by zheref
Send the branch out — gyo (lint) before rewriting history, squash only unpushed commits, bring the base underneath them, gyo again if catch-up changed the tree, and push. The whole skill runs only on the maintainer's publish call. It never runs project-wide tests or coverage; those belong to mukai through kotoamatsukami and byakugan.
backlog-board
by zheref
Render the current backlog as the Kurapika gate board — the same sweep, arguments and gate assignment as hatsu:backlog-state, painted as a Rikugan page by nen report render --variant register instead of a markdown table. Use when the maintainer asks to see the board, the gate register, or the state as a page, or invokes hatsu:backlog-board <repo all>@<G1 G1-M G2 G3 G4 G5 all> [every <turn state-change once>] — the trailing clause makes the board re-render on every turn or whenever a scoped item's state changes, instead of the once-and-stop default. This skill also owns the render path futon, backlog-loop and the dated final report use. Strictly read-only — it never labels, merges, pushes, comments or opens anything.
amaterasu
by zheref
Build and start the app for the declared launch target from the maintainer's core working directory — never from a worktree — and hand back the exact command that did it, copied verbatim out of the dry run. Runs as phase four of ren; invoke hatsu:amaterasu [<target>] by name to relaunch or switch targets. A disconnected device is reported by its declared name and falls back only to the declared simulator; a session in a worktree reports the command instead of running it.
jujutsu
by zheref
Pair a new device with this machine and register it as a named launch target, once — walk the maintainer through the on-device steps, verify with the platform's own probe, then write the target into nen/contract.json and open the declaration PR at its repository's own gate. Use when the maintainer invokes hatsu:jujutsu pair <device>, asks to set up a new phone, tablet, simulator or desktop target, or when hatsu:amaterasu reports a launch target this machine cannot resolve. It never taps a trust prompt, never changes a security setting and never merges the declaration PR.