Nen reference
Every verb of the deterministic CLI, grouped by family, from Nen's own usage document.
Nen detects, computes, formats and verifies. It never decides anything that requires judgment: a human or an agent reads the verdict and decides what to do about it. Every verb accepts --repo <path>; the --json column says which verbs also print the same data as JSON.
Read from the repositories at commit: hatsu 3c582c18a4 (v0.159.0) · nen d7a720ddcd (v0.29.0) · handbooks 39b8e06d3c (v0.13) · 2026-11-04
Try it
Two commands that need nothing but a clone: no target repository, no network, no credentials.
$ nen commit format --type feat --subject "add readiness verb"
feat: add readiness verb
$ nen commit format --type feat --subject "add readiness verb" --json
{
"message": "feat: add readiness verb"
}source: nen:README.md § Try it
Verb index
nen pr
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen pr ready | CON-32 readiness verdict for one pull request | nen/gates.json + nen/repos.json (or --gates/--reviewers/--gh-repo), github (gh api graphql/rest) | yes |
nen pr staleness | stale + Ready merge-permission arithmetic over a verified-wake history | caller-supplied --wakes-from JSON file, no schema/git/gh | yes |
nen pr body-check | checks a PR body against caller-supplied requirement patterns, or, with no --requirements-from, against the headings of the repository's own PR template, each required present and filled (named as derived, with where it was read) | caller-supplied --body-from/--requirements-from files; else the PR template (pull_request_template.md/.txt at the root, .github/ or docs/, or PULL_REQUEST_TEMPLATE/*.md/.txt) in the working tree, or at --base <ref> through git (rev-parse, ls-tree, cat-file) | yes |
nen pr sections resolve | resolves a caller-owned section catalogue by kind, family and conditional facts | --catalogue JSON; optional workflow.json pr.sections overrides | yes |
nen pr sections family | folds taxonomy jobs into the catalogue family with the most jobs, ties by declared precedence | --taxonomy and --catalogue JSON | yes |
nen pr fetch | one typed snapshot of a PR: head sha, mergeability, check rollup, per-commit reviews, review threads, pending review requests | github (gh) | yes |
nen pr converge | read-only: compares the AC rows of every issue a PR closes with the PR body's verify rows, per criterion; the blocking rules are the caller's catalogue (defaults equal Hatsu's) | github (gh pr view, gh api issue reads) | yes |
nen pr next-blocker | the first blocking condition, in fixed order (conflict, red check, owed round, unresolved thread, missing body requirement) | nen/gates.json (or --gates), github (gh) | yes |
nen pr cascade-main | merges (never rebases) the trunk into the current branch and pushes on a clean merge, or stops there under --no-push | git (fetch/merge/push, reaches origin) | yes |
nen pr retarget | gh pr edit --base, for a stacked PR after its predecessor merges | github (gh) | yes |
nen pr request-reviews | resolves each --add-reviewers login as a Bot or a collaborator, then requests it through gh pr edit --add-reviewer (User/Team) or GitHub's requestReviews mutation (Bot, botIds) — the one route --add-bots logins and node ids travel too | github (gh api graphql to resolve + request; gh pr edit for the user route) | yes |
nen pr edit-body | replaces a pull request's body outright with a file's bytes, certifying the number IS a pull request before any write | github (gh api read to certify, gh pr edit unless --dry-run) | yes |
nen pr edit-title | replaces a pull request's title with a file's one line, certifying the number IS a pull request before any write and reading the title back after it | github (gh api read to certify and read back, gh pr edit unless --dry-run) | yes |
nen pr mark-ready | moves ONE existing draft pull request out of draft through GitHub's markPullRequestReadyForReview mutation, after certifying it is an open PR at the pinned head, and reports success only on a not-draft read back — never the CON-32 verdict, which stays pr ready's | github (gh api graphql: one certifying read; the mutation and a read back unless --dry-run) | yes |
nen pr threads | a pull request's review threads: list them all (paginated to completion, with path, line, author, first comment and url), reply to one, resolve one, or settle a batch from one file | github (gh api graphql: one read walk; one mutation for reply/resolve, one reply and one resolve per entry for settle, unless --dry-run) | yes |
nen pr open | open exactly one pull request from a head the remote already holds at the local sha, refusing an unpushed head at exit 2; one already open for the head against the same base is returned as opened: existing at exit 0, against another base at exit 1 | git (symbolic-ref, rev-parse, ls-remote), github (gh pr list always; gh pr create unless --dry-run) | yes |
nen pr ledger | post an effort's ledger slice (phases, usage totals, schema-checked findings, proof index; nen.pr.ledger/v0.1) as ONE PR comment, edited in place on a re-post; read it back from the authenticated login's comment only (ok / stale / could-not-read), and --restore the phase ledger on a fresh clone | github (gh api pulls, user, graphql comments with author and editor; POST or PATCH a comment unless --dry-run), <git-common-dir>/.nen/phases|usage/, the --findings, --findings-schema and --proof files | yes |
nen pr merge | the bounded merge, two forms. --release-unit: pr ready (in-process) + head pin + pr body-check (live body, one fetch) + release unit-check (policy from the PR's base) + whose-pr. --delivery: a run's own PR into a non-main, unprotected base — a protected base is refused by ruling (exit 2), then base + pr ready + head pin + pr body-check + whose-pr (viewer and run-form head). Every gate must pass; gh pr merge --merge --match-head-commit only under --run | github (gh pr view, gh repo view, gh pr list, gh api contents/trees/user/branches/rules, gh pr merge unless plan-only), nen/gates.json, nen/workflow.json, nen/repos.json (a CODE#n ref) | yes |
nen gate
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen gate derive | derive G2 vs G4 from a changed-file set against two caller-supplied path sets | git diff (for --range), no schema file -- path sets are flags | yes |
nen split
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen split verify | prove the union of per-axis branch diffs equals one original diff | caller-supplied --original/--branches diff files, no git/gh | yes |
nen wc
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen wc classify | classify the working copy as must-move / on-branch-dirty / on-branch-clean | git (branch, status, ahead-count) | yes |
nen wc squash | fold every commit since git merge-base <onto> HEAD into one, validated message, refused if dirty / --onto not an ancestor / any commit already on the upstream | git (status, merge-base, log, fetch, reset --soft, commit -F, interpret-trailers --parse --no-divider, config trailer.separators and cat-file commit for the folded commit's trailer read-back -- exit 3 on an injected one, #273), nen/workflow.json under --repo | yes |
nen wc catch-up | fetch origin/<base> and rebase (nothing published) or merge (something is) the current branch onto it; stop on a conflict with both sides of every path, its class (manifest / changelog / mirror / other, by nen/contract.json's mechanical block) and the abort line, never picking one -- exit 3 when every path is mechanical, with the commands to run printed and none run; re-run on the same tree to continue a staged resolution, --abort to back out | git (status, fetch, rev-list, rebase / merge, diff --diff-filter=U, show :2:/:3:, rebase --continue / commit --no-edit, --abort), nen/contract.json's mechanical block under --repo (only on a conflict) | yes |
nen wc publish | push the current branch under its own name to the remote its upstream names (origin, or --remote, when it has none), refusing a detached HEAD, the trunk as local name or as destination, an upstream of another name unless --set-upstream (which publishes to <remote>/<own name> — --remote, else origin, else the upstream's remote — and retracks it there), any refspec/force shape, and reporting needsForce at exit 1 instead of forcing | git (symbolic-ref, fetch, merge-base, rev-list, push, reaches the upstream's remote) | yes |
nen wc prune | validate an explicit cleanup plan and remove named remote branches; worktree/local-branch/tracking-ref removals refuse; host links are read-only | plan file, local Git refs/worktrees, exact configured remote branch reads | yes |
nen wc worktrees | list every checkout of the project, core first: core/in mark, branch or detached, uncommitted count, +ahead/-behind against origin/<base>, HEAD, last commit and age, path | git (rev-parse --git-common-dir, worktree list, status, rev-list, log) | yes |
nen wc swap | bring a worktree's committed tree into the core checkout (view: HEAD detached; --take: the branch), --return it with core's parked work restored, --status; core's work parked in a pinned commit, never stashed; exit 3 on a dirty tree | git (worktree list, status, read-tree/add/write-tree/commit-tree through a temporary index, update-ref, reset --hard, clean -fd, checkout, diff) | yes |
nen wc worktree | keep ONE detached worktree at <core>/.nen/worktrees/<name> at origin/<base>'s fetched tip -- created, reused, moved, or (its registration outliving its directory) that one registration dropped and recreated; refused, never discarded, when dirty, and refused for a stray directory, a symlink or a sibling registration; --copy-from-core copies gitignored, untracked regular files from core after proving the source in core and the destination at the tip and in the worktree, through a temp file and a rename | git (rev-parse --git-common-dir/--git-dir, check-ref-format, fetch, ls-remote, rev-parse, ls-files, check-ignore, ls-tree, worktree list/add/remove, status -z, diff --name-only, checkout --detach), the files named by --copy-from-core in core, the copy record in the worktree's git dir | yes |
nen wc overlap | file disjointness of parallel efforts, computed: each effort's merge-base diff against --base (default origin/<branch.base>), plus an always-overlapping list counted as every effort's; verdict disjoint / stack(<order>) (git's chain when the branches chain, else the --efforts order) / unknown; --declared paths stand in before authoring | git (diff --name-only -z <base>...<effort>, merge-base --is-ancestor), nen/workflow.json under --repo (alwaysOverlaps; branch.base without --base), the --declared file | yes |
nen wc ahead | the commits and diff stat beyond a NAMED reviewed head, read from the clone with no fetch; verdict ahead <n> (exit 0) / even (exit 3) / diverged -- the reviewed head is not an ancestor, never a count (exit 1) / unreadable -- a ref the clone does not hold, never zero (exit 2) | git (rev-parse --verify <ref>^{commit}, merge-base --is-ancestor, rev-list --count <of>..<head>, diff --numstat -z --no-renames <of> <head>) | yes |
nen stage
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen stage triage | flag secret-shaped, binary, out-of-scope and unmentioned-deletion files before staging; report git-ignored paths separately, never counted toward the exit code; --range <base>..<head> triages a committed range instead of the working copy — names and blob sizes over every change any commit made (in-history for a finding not in the net change), deletions and mentions over the net diff from the merge base — an unresolved, malformed or unrelated range exit 2 and never a fall back | git status --porcelain; with --range: git rev-parse, merge-base, rev-list --count, log --raw, diff --raw, cat-file --batch-check | yes |
nen stage list | the exact add list — every modified, added, renamed, deleted and untracked path triage called clean, minus flagged and git-ignored ones, each exclusion named with its reasons, unmerged paths, embedded repositories and undecodable names held off with the list withheld, a worktree rename's original included; --repo must be the top; newline (C-quoted where needed) or --nul form to feed git add --pathspec-from-file=- verbatim, withheld on a flag (exit 1), exit 3 when empty | git status --porcelain | yes |
nen stage check | --exclusive: exit 1 when an issue (or any of --issues) carries two stage-family labels at once, the family read from nen/labels.json (<namespace>:stage/<leaf>), exit 2 when it declares none; names both, picks neither | nen/labels.json under --repo, github (gh issue view --json labels) | yes |
nen backlog
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen backlog fetch | fetches open issues + open PRs fresh over 'gh api' (never cached) and assembles one row per effort | gh (issues, pulls, paginated) | yes |
nen backlog order | applies backlog-loop's severity/blocks/consumer/age priority order to a pre-fetched row set | local file (--rows-from) | yes |
nen board
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen board build | assembles a Board from already-computed rows (gate from 'gate derive', colour from 'color status') | local file (--rows-from) | yes |
nen board render | renders a Board snapshot as the padded-markdown table the retired shell board script established | local file (--board-from) | yes |
nen board diff | field-level diff of two Board snapshots, by row id | local files (--before, --after) | yes |
nen epic
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen epic next-wave | flips a completed child, redraws the progress bar, computes the next releasable wave | local file (--body-file), optional write (--out) | yes |
nen effort
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen effort classify | classifies one epic/child against senkei's five-class (plus undecidable) taxonomy from caller-supplied facts | local file (--input) | yes |
nen loop
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen loop slots | counts how many CI and local concurrency slots are free, from a caller-supplied efforts file or -- --from-run -- one built from a run's manifest and live reads (PR state, pr ready, the stop marker), and explicit caps, a local slot freeing by --repo's declared idle.localSlotFrees (under an idle profile) or monitor.localSlotFrees | local file (--efforts), or the run manifest, github (gh pr view, pr ready's reads) and git (worktree list) with the stop markers it names; nen/workflow.json under --repo | yes |
nen loop iterate | claims one iteration of an izanagi loop against its own up to <N> cap, refusing the claim past it | <git-common-dir>/.nen/loop/<id>.json and <id>.opened (reads and writes under a lock; .nen/loop/ under --repo only outside a git repository) | yes |
nen phase
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen phase | records when a workflow phase began and ended for one effort, with the elapsed milliseconds and exit code, in a per-effort ledger | <git-common-dir>/.nen/phases/<effort>.json (under --repo outside git; reads and writes); git rev-parse/worktree list to find it, no gh | yes |
nen session
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen session | records caller-reported session identity and effort dial per effort, and shows the ledger | <git-common-dir>/.nen/sessions/<effort>.json (under --repo outside git); git rev-parse/worktree list to find it, no gh or harness reads | yes |
nen usage
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen usage | records what a surface and model spent on an effort -- token counts, minutes, the source of the numbers, or notReported -- in a per-effort ledger, and shows the ledger with totals per surface and model | <git-common-dir>/.nen/usage/<effort>.json (under --repo outside git; reads and writes); git rev-parse/worktree list to find it, no gh | yes |
nen warmup
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen warmup | warms a REGISTRY: detects stale/unpinned consumer versions, plus an optional handbook-question sweep. Reads only. Not nen shu warmup, which warms a working copy | nen/repos.json, optional local files | yes |
nen watch
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen watch until | polls one read-only observation command — or, with --pr, one pull request's readiness facts through pr ready's own read, or its merge (--until merged) — until its condition holds, paced and bounded | whatever --command names (typically git or gh); with --pr, GitHub GraphQL + REST (token from --token-env, default GH_TOKEN), as pr ready | yes |
nen label
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen label apply | applies one label or a batch of ref/label pairs and appends an after-the-fact ledger line | nen/labels.json; gh only with --run | yes |
nen labels
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen labels sync | creates missing labels and updates only differing taxonomy labels | nen/labels.json; gh read even with --dry-run | yes |
nen labels rename | renames labels in place, preserving every issue association, idempotently | gh label list (always), gh label edit unless --dry-run | yes |
nen classify
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen classify labels | validates a classification taxonomy file and prints the label set it defines (axis or family prefix + key, colour, description) | local file (--taxonomy) | yes |
nen classify install | compares the taxonomy's labels with nen/labels.json (present, drift, absent, foreign), rewrites the declaration with --write, or syncs only those labels to GitHub with --sync once the declaration is landed | local file (--taxonomy), nen/labels.json; gh only with --sync | yes |
nen classify status | which issues carry a label on every axis, which are missing one, which carry an unknown key, and whether the declaration and GitHub both hold the taxonomy's labels | local file (--taxonomy), nen/labels.json, gh (issue reads, label list) | yes |
nen classify apply | validates a classification plan whole, then applies it as labels (listing low-confidence rows, skipping labels already present), one ledger line per application | local file (--taxonomy, --plan), nen/labels.json, gh (issue reads; gh issue edit only with --run) | yes |
nen direct
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen direct registry | validates a model-direction registry file and prints it: the snapshot date, each alias (provider, family, surface/tier, snapshot quote), the surfaces and the live-lookup sources | local file (--registry) | yes |
nen direct resolve | resolves a classification (languages, jobs, repository kind) to a recommended alias, surface and effort: derives the domain, reads each (job, language) cell, aggregates, spells the alias from nen/workflow.json, scores the effort, and reports any mismatch with the session (exit 0, never blocks); --record files the result under <git-common-dir>/.nen/direct/ | local files (--registry, --taxonomy), nen/workflow.json under --repo | yes |
nen direct matrix | enumerates every (job, domain, language) answer resolve gives, for a consumer that renders the whole table: per job and domain the witness issue that derives it (or unreachable), the route, fallback and phase, and per language column (* the shared one) the pair, the aggregate, the winner and runner-up resolved and the effort -- computed by resolve's own functions, owning no rule | local files (--registry, --taxonomy), nen/workflow.json under --repo | yes |
nen direct answer | writes the maintainer's picker answer (continue or stop) and its time into the record direct resolve --record filed, replacing an earlier answer and leaving every other field unchanged; a missing record is a failure | <git-common-dir>/.nen/direct/<encoded id>.json (under --repo outside git; reads and rewrites); git rev-parse/worktree list to find it, no gh | yes |
nen schema
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen schema check | loads and validates the files a repository is expected to carry under nen/, reporting each one's verdict and any legacy schemas/ leftover, and a consumer's .claude/rules/ canon mirror against its bindings | nen/labels.json, repos.json, colors.yml, gates.json, contract.json (optional), workflow.json (optional), .claude/canon-values.yml (optional) and its git history | yes |
nen schema set | writes ONE value into a nen/ JSON declaration by RFC 6901 pointer -- an existing scalar replaced, a member added to an existing object, an item appended to an array (/-), or an object or array replaced whole by one of its kind -- every other byte kept, the result validated by that file's own loader before anything is written, then written atomically and read back; a gate-change pointer needs --gate-change; --dry-run writes nothing | the named nen/ declaration under --repo (reads and rewrites); no git/gh | yes |
nen color
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen color status | resolves one row's colour token by the repository's own nen/colors.yml precedence | nen/colors.yml | yes |
nen repo
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen repo resolve | resolves a repository token (code, slug, short name, or 'all') against the registry, or the cwd's own origin | nen/repos.json; git (no-token form) | yes |
nen repo inventory | senkei's live enumeration: epics + children, integration branches, open PRs | gh (issue list, api sub_issues/branches/compare, pr list) | yes |
nen repo scenario | reads back the scenario recorded for one --target in the registry | nen/repos.json | yes |
nen repo family | one product family from the registry's families[]: the spec repository (role spec, gate G2) and each member's code resolved to owner/name with its platform | nen/repos.json under --repo | yes |
nen repo classify | one verdict about a repository: role (canon / consumer / spec / unregistered), kind (product / process / library / unknown), stack, lanes, and the gate a change there stands at | nen/repos.json + nen/contract.json under --repo; git remote get-url origin when no --target | yes |
nen ref
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen ref format | formats the <CODE>-<IS|PR>-#<N> notation, checking the code against the registry first | nen/repos.json | yes |
nen ref parse | parses a token in object notation | none | yes |
nen ref resolve | where one canon citation (<path> § N, § Title, #anchor, HR-n, CON-n) lands, or unresolved with candidates; never re-aims one | the cited Markdown file under --root | yes |
nen release
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen release preflight | every getsuga §2 release-cut precondition, checked and reported whole | github (gh variable get, git ls-remote), CHANGELOG.md, changelog.d/, git log --merges, git ls-tree/cat-file (the CHANGELOG's history, for the release-PR allowance) | yes |
nen release resolve-target | resolve a release token (main/last-commit/checkout/hash/branch) to a SHA and test trunk ancestry | git (fetch/rev-parse/merge-base, reaches origin) | yes |
nen release self-check | whether a release PR should list itself in its own range | git (merge-base ancestry, local only) | yes |
nen release unit-check | whether a pull request's changed files stay inside --repo's declared release.unitPaths | github (gh api --paginate --slurp repos/{owner}/{repo}/pulls/{n}/files), nen/workflow.json, nen/repos.json (a CODE#n ref) | yes |
nen changelog
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen changelog fragment-required | whether a change owes a changelog.d/ fragment (CON-33(a)) | git diff/caller files, CHANGELOG.md at base+head, optional nen/repos.json-shaped --base-repos/--head-repos | yes |
nen changelog collate | collate every changelog.d/ fragment into a new dated CHANGELOG.md section (CON-33(b)) | changelog.d/, CHANGELOG.md | yes |
nen changelog completeness | every PR merged in a range has a CHANGELOG entry or an (un)collated fragment (CON-33(c)), except the range's terminal PR when its merge introduced the dated section | git log --merges, git ls-tree/cat-file (the CHANGELOG's history, for the release-PR allowance), CHANGELOG.md, changelog.d/ | yes |
nen tag
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen tag cut | cut an annotated git tag pinned at an explicit SHA, never auto-pushed | git (tag/ls-remote/merge-base; --push also reaches origin) | yes |
nen fanout
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen fanout compute | which registered consumers (nen/repos.json) are affected by workflows changed in a release range | nen/repos.json, git diff, .github/workflows/ | yes |
nen fanout record | the same computation, appended to an audit ledger file | nen/repos.json, git diff, .github/workflows/, ledger file | yes |
nen report
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen report data | one document describing a branch against a base: commits, changed files (with a caller-supplied tier), the evidence seam, the lane's coverage report if it is on disk, the build proof, the last recorded stop, and -- only when one of the five register flags is given -- the issues and pull requests the effort is about; then where the effort is (worktree, stage, gate, turn, local clock), derived | git (rev-parse/symbolic-ref/remote get-url/log/diff), the zoneinfo file the zone names, nen/repos.json for the gate, nen/contract.json for the lane, .nen/proof/<lane>.json, .nen/last-stop.json, the declared coverage artifact, a caller-supplied --tiers file; under --target/--prs/--issues/--backlog also github (gh api, gh pr view) and nen's own in-process readiness gate; under --objects-from a caller-supplied file instead | yes |
nen report render | fill a template with a data document and write the result: {{token}}, {{{token}}}, {{#each}}, {{#if}} and nothing else, refusing an unknown token by name; --variant injects a declared variant's section flags and --graph injects a validated architecture-delta graph | caller-named --template + --data (+ --graph) files, nen/workflow.json's reports.sections under --variant; writes --out, inside --repo, unless --dry-run | yes |
nen report mermaid | print the mermaid text for a graph document and nothing else | a caller-named --graph file; writes nothing; no git/gh | no |
nen review
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen review scopes | which review scopes a branch diff raises, off the repository's own review.scopes block, plus the changed paths no scope claims | nen/workflow.json's review block, git diff --name-only; writes nothing; no gh | yes |
nen audit
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen audit deps | a directory's dependency pins read from its lockfile or Package.resolved (never by running its package manager) and, with --query, asked about at the declaring contract's OSV querybatch endpoint; four exits: clean, findings, wiring, not scanned | the --contract row (an absolute JSON file), package.json and the lockfile directly under --repo (pnpm, yarn, npm) or Package.resolved (root, .xcodeproj, .xcworkspace), OSV over https (with --query); never git, gh or the package manager | yes |
nen surface
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen surface mirror generate | render every <name>/SKILL.md under a skills directory into another agent surface's own layout (codex, cursor, antigravity): the body verbatim but for its relative links, re-aimed for the depth each copy lands at, the frontmatter reduced to the keys that surface documents, invocation mentions respelled, personas written where the surface keeps them — plus, per flag, the surface's hook manifest (--hooks), rules file (--rules), permission pack (--permissions) and model aliases (--models), and a --stamp in the marker | caller-named --source + --agents directories and pack files; writes --out; no git/gh | yes |
nen surface mirror check | regenerate that mirror in memory and diff it against the committed --out: missing / extra / stale (generated for another surface, with --stamp for another version, or by a build before relative links were re-aimed) / hand-edited — or, with --installed in place of --out, against an INSTALLED copy on this host (a plugin cache directory, a consumer's .codex/, .cursor/, .agents/) under its own contract, so a warm-up copies only on drift; --surface claude-code compares a plugin tree verbatim — and, with --plugin <name>, judges a Claude Code plugin cache or skills-directory install in the plugin's own layout against an independent source, six verdicts on six exits | caller-named --source + --agents + --out or --installed; with --plugin: --source's trees, the copy, <config>/plugins/*.json and <config>/skills/<name>, plus read-only git rev-parse/symbolic-ref probes of the stand-in and served checkouts; writes nothing at all; no gh | yes |
nen surface install | make, re-point or report a host's FIRST-PARTY install of a plugin from a checkout, per surface: the Claude Code skills-directory link with the hand-over of a prior marketplace copy, the Codex marketplace and plugin, the Antigravity global plugin link -- never replacing what it did not make, never editing a settings file, every write read back | the checkout's manifests; the surface's own directory (--config-dir) and registry files; claude / codex / agy and one git rev-parse; writes a link under --config-dir and runs the surface's install CLI unless --dry-run; no gh | yes |
nen surface status | the version each surface serves for a plugin, read back from claude plugin list --json, codex plugin list or the linked plugin.json, and whether it is a given checkout; with --trees, the copies Claude Code SERVES judged as check --plugin judges them | the surface's directory and registry files; claude / codex / agy list and validate commands; with --trees, the copies and the source; writes nothing; no gh | yes |
nen surface capabilities | what a running session on a surface can do -- picker, subagent, hook events and decision key, worktree isolation, artifact, notify, permissions file and shape, agent model key, rules file and limit, description budget -- as data with a citation per row | nothing; a table this binary ships | yes |
nen runner
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen runner inventory | every self-hosted runner a repository has, each name parsed as <machine>-<consumer>R<slot> or runner 0, grouped by the pools --repo's runners block declares (online, free, and the runners still without the pool's own label) plus the unpooled, and the runner package GitHub offers with its SHA-256 | github (gh api GET runners, every page, and runners/downloads); nen/workflow.json with --repo or --pool | yes |
nen runner plan | which runners to add: the lowest free slots for a machine and consumer code, install dirs under the root in the host's separators, the service identity (or ask), the pool's mode, and the package with its SHA-256 -- the nen.runner.plan/v0.2 contract, --out writes it; on the pool's own host, a stderr warning (exit 0) when the account already runs another repository's runners of different visibility | nen/workflow.json (runners), nen/repos.json (product_codes), github (gh api GET), this host's runner services (powershell Get-CimInstance / systemctl, read-only); writes --out only | yes |
nen runner script | render a plan's host script -- PowerShell 5.1 (elevated; locks the runner root first, asks the password once, mints each token itself, hands both to config.cmd through the environment, never argv; an interactive Windows plan asks no password and registers logon tasks instead of services), bash for Linux (sudo) and macOS (as yourself) -- and print the one launch line; never runs it | a caller-named --plan file; writes --out unless --dry-run; no gh | yes |
nen runner verify | poll the runners list until every expected name is present, online and labelled -- with --pool, with every label of that pool, its own pool-<id> included; never exits 0 on a partial pass | github (gh api GET runners); nen/workflow.json with --pool | yes |
nen runner workflow | render a pool's preflight workflow from a caller's @@NAME@@ template, refusing a leftover placeholder or invalid YAML, and a changed file without --force | nen/workflow.json (runners), a caller-named --template; writes .github/workflows/<preflightWorkflow> (or --out) unless --dry-run | yes |
nen runner preflight | dispatch the pool's preflight workflow, find the run it created by id, and wait for its verdict; a job still queued at the deadline is named -- no free runner picked it up | github (gh repo view, gh run list, gh api GET runs/jobs; gh workflow run unless --dry-run) | yes |
nen runner enable | set a pool's enable variable only after re-reading a completed, successful run of its own preflight whose jobs asked for its labels, dispatched on the default branch with the default branch's own workflow blob; read back, idempotent | nen/workflow.json (runners), github (gh api GET runs/jobs/contents, gh repo view, gh variable get; gh variable set unless --dry-run) | yes |
nen runner relabel | add a pool's own label, pool-<id>, to runners registered before it existed (#340) -- only runners named with --runner (--run without it is exit 2); a dry run without --runner lists the candidates; every write read back | nen/workflow.json (runners), github (gh api GET runners and runners/<id>/labels; gh api POST runners/<id>/labels with --run) | yes |
nen run
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen run rerun-failed | re-run a workflow run's failed jobs (gh run rerun --failed) | github (gh) | yes |
nen run start | start a batch run's manifest (nen.run/v0.1) at <git-common-dir>/.nen/runs/<id>.json with its repository and launch-time idle answers (HR-5); the same answers again is the resume, other answers or another repository refused | git (rev-parse --git-common-dir); writes the manifest unless --dry-run | yes |
nen run append | record one PR the run opened, whatever its base, read live (base, branch, head); a PR created before the run started is refused; idempotent on the same facts, updated on a moved head or base, refused on another issue, kind or effort | git (rev-parse --git-common-dir), the manifest, github (gh pr view); writes it unless --dry-run | yes |
nen run park | record an effort parked on an unanswered ask-once row (HR-5's park state), once | git (rev-parse --git-common-dir), the manifest; writes it unless --dry-run | yes |
nen run import | read Hatsu's futon run manifest (hatsu.futon.run/v0.2) into this one, every PR read live, so one manifest owns the run; idempotent, the Hatsu file never written; a conflict or an unread PR refuses the whole import | git (rev-parse --git-common-dir), <git-common-dir>/hatsu/futon/run-<id>.json or --from, github (gh pr view); writes the manifest unless --dry-run | yes |
nen run verify | read every PR the run recorded live and report open, merged and closed-unmerged with the unmerged list; an unread PR is exit 1 and counted nowhere | the manifest, github (gh pr view); moves a legacy-path manifest once unless --dry-run | yes |
nen run budget | wall-clock minutes since the run's start and the efforts' recorded tokens against a ceiling (flags, or idle.budget); an unread token sum is unevaluated; --claim refuses at exit 1 once reached or unevaluated | the manifest, <git-common-dir>/.nen/usage/<effort>.json, nen/workflow.json (idle.budget, only for a ceiling not flagged); moves a legacy-path manifest once unless --dry-run | yes |
nen run record | a caller's resumable run record (hatsu.spec.run/v0.1) validated against a schema shipped as data — the run id matched whole before any path is built, schema, caller and runId before the fields — and read or written whole at 0600 in a 0700 XDG state directory | ${XDG_STATE_HOME:-$HOME/.local/state}/<schema dir>/; the --from file; WRITES the record under write unless --dry-run | yes |
nen issue
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen issue search | duplicate-search the backlog before filing: four gh passes (open subject, recently-closed subject, files+rule-ids, lane) reported with what each was for | gh (issue list x4) | yes |
nen issue open-pr-check | which candidate issues carry an OPEN pull request that closing would orphan | gh (pr list) | yes |
nen issue file | file an issue with labels and assignee IN the create call, refusing any label the target taxonomy does not carry or that a forbidden family names | nen/labels.json; gh (issue create) | yes |
nen issue comment | post one caller-supplied comment on one issue (or, deliberately, one PR) number | gh (issue comment / api) | yes |
nen issue attach-sub | attach children as GitHub sub-issues under a parent, certifying every number as an ISSUE (never a PR) before the first write | gh (api reads, sub_issues POST) | yes |
nen issue consolidate-close | the file->attach->close choreography: union labels, reduce one severity family to its strongest label, guard every child for an open PR, close each with a comment | nen/labels.json; gh (api reads, sub_issues POST, issue close/comment) | yes |
nen issue chain-position | classify where an OPEN issue sits on its delivery chain, from its labels alone | gh (api read) | yes |
nen issue terminus | classify which object ends an issue's delivery run (its own PR, each child's PR, or one integration-branch delivery PR) | gh (api read) | yes |
nen issue reconcile | read-only, proposes only: which OPEN issues a MERGED pull request already closes, each proposal citing the PR, its merge commit and the closing reference | gh (repo view, issue list, api graphql search and per-PR commit queries, api compare, api labels when --hold-labels is given, pr list for delivery PRs and the open-PR guard) | yes |
nen issue edit-body | replaces an issue's body outright with a file's bytes, certifying the number is an ISSUE (never a PR) before any write | gh (api read to certify, issue edit unless --dry-run) | yes |
nen issue body-check | read-only: does an issue body carry every section its kind requires in the caller's catalogue, with content patterns, contiguous and measurable numbered rows, and vague-word advisories | --body-file or gh (api read), the --requirements-from catalogue | yes |
nen issue questions | read-only: counts an issue body's open OQ-{n} rows, resolved ones and [NEEDS ...] markers, one issue or a comma-separated batch; exits 1 while any question is open, NEEDS-marked or malformed | --body-file or gh (api read) | yes |
nen issue criteria | read-only: lists an issue body's AC-{n} acceptance-criterion rows with their text; a body with none is not verifiable | --body-file or gh (api read) | yes |
nen idea
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen idea file | file an idea issue (reusing issue file's own choreography), then read it back over the API and diff title/body/labels against what was submitted | nen/labels.json; gh (issue create + api read) | yes |
nen scaffold
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen scaffold init | stand an EXISTING repository up: the directory skeleton, the trailer-enforcing commit-msg hook, the trunk-guarding pre-commit hook, a canon-values.yml template, nen/contract.json's project block, nen/workflow.json's policy, the schemas/->nen/ copy migration, the stack's CI workflow, .gitignore upkeep, and a closing shu tools CHECK that installs nothing | nen/contract.json + nen/workflow.json (both hooks are generated FROM the policy) + the legacy schemas/ copies; the bundled profiles pack and templates/; writes to disk under --repo; spawns the version probes the target declares (never on --dry-run) | yes |
nen scaffold new | write a FRESH tree for one stack into an empty --dir: the template's files with {{name}} substituted, the CI workflow, .gitignore, both git hooks, nen/workflow.json's policy, and nen/contract.json as shu detect proposes it off the marker just written -- every post-step PRINTED, none run | the bundled profiles pack and templates/; writes to disk under --dir; spawns nothing at all | yes |
nen scaffold migrate | write each ABSENT nen/colors.yml and nen/gates.json from a seed that widens nothing (no colour category; a Copilot round owed at head on every PR, a delivery carve-out matching no author), read each back through its loader, and never open an existing file -- idempotent; the command schema check names for each missing one | writes to disk under --repo; spawns nothing | yes |
nen canon
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen canon resolve | resolve a target repo's always-load handbook set plus its ONE stack handbook, from the scenario nen/repos.json records for it | nen/repos.json | yes |
nen canon pin | read the canonical handbooks repository a consumer mirrors and the TAG it is pinned to, from the pinned field on that repository's maintained_tools entry -- data a sync checks the canon out at, and a drift check holds the mirror to; with --write <tag>, MOVE that pin -- one value, every other byte kept -- only to a tag the canon checkout carries | nen/repos.json; with --write, the canon checkout canon checkout resolves (read-only, isolated git; fetches nothing) and an atomic write of nen/repos.json unless --dry-run | yes |
nen canon checkout | resolve WHERE the canon checkout is on this machine -- --canon-checkout, then the variable the pinned entry's checkout_env names, then its checkout path template -- and verify it is a clean checkout of the pinned source at the pinned tag, reporting every step | nen/repos.json + the environment; read-only, isolated git (rev-parse, remote get-url on the checkout and the consumer, status, ls-files); fetches nothing | yes |
nen canon mirror generate | render every canonical rule file, {{TOKEN}}s bound, into the rules location of EACH agent surface the consumer declares (a directory of marked files, or one marked block inside AGENTS.md), writing only changed files, deleting marked orphans, refusing to touch a hand-written file | --rules-dir, or --stack-dir/--leaf inside the canon checkout canon checkout resolves (read-only git) + --canon-values; the surface table (src/surface/rules.ts); writes under --repo; no gh | yes |
nen canon mirror check | render the mirror in memory and diff every declared surface's committed copy against it: ok / missing / extra / stale / hand-edited per file, foreign for the consumer's own | --rules-dir, or --stack-dir/--leaf inside the resolved canon checkout (read-only git) + --canon-values; the surface table; reads under --repo; --markdown-out writes its table (and its parent directory) there; no gh | yes |
nen canon lint | a canon repository's prose held to a caller-owned rules contract (each rule's class picks the check) behind a shrink-only baseline; fenced code and quoted words exempt; never green over a file it could not read | nen/workflow.json canon.lint, the --rules contract and the files it names (version source, decisions, rulings, declared values), the --baseline and --base-baseline, the Markdown its include globs match under --root; with --base, git (merge-base, diff, show) | yes |
nen canon clause check | a clause id space (HR-{n}, CON-{n}) held unique -- definitions counted, citations never, gaps a notice -- and, with --leaves, every changed clause matched by a change in each file citing it or a no-leaf-change: line | --file under --repo; --base as a file or git show <ref>:<path>; with --leaves, git (ls-files, diff) and the --body-from file | yes |
nen quality
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen quality tooling | look up the e2e/adversarial/perf tooling recorded for a scenario in a caller-supplied table | caller's own --table JSON (never a table shipped in nen) | yes |
nen quality perf-compare | classify a measured-vs-baseline regression at QA-13's fixed 10%/25% thresholds | none (pure arithmetic over the two numbers given) | yes |
nen quality method-check | validate a QA-15 method block: device/OS stated, Release with no debugger, n>=5 with the first discarded, median+p90, thermal+network stated | caller's own --input JSON method block | yes |
nen commit
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen commit format | format and validate ONE Conventional Commits message's shape (type, subject, scope, breaking, trailers) the repository's subject-case rule (commitlint's own when readable as data, else commits.subjectCase), and its body/footer line lengths, wrapping --body to them (commitlint's own when readable as data, else commits.bodyMaxLineLength, else 100) -- never its content | on every run: nen/workflow.json under --repo (the attribution-trailer policy, commits.subjectCase and commits.bodyMaxLineLength), and the commitlint config commitlint would load from --repo's root (data forms parsed; JS/TS never executed) | yes |
nen commit check | is this working copy the one a green build proved? compares .nen/proof/<lane>.json's tree against the tree now | .nen/proof/<lane>.json under --repo, git (add/rm/write-tree into a scratch index) | yes |
nen commit write | commit the index with a message file validated under commit format's own rules plus every --trailer, refusing a red --require-proof and an empty index; git commit -F is the one write | nen/workflow.json under --repo (the trailer policy, commits.subjectCase and commits.bodyMaxLineLength), the commitlint config at --repo's root (subject-case, body-max-line-length, footer-max-line-length), .nen/proof/<lane>.json and the scratch-index hash under --require-proof, git (diff --cached, commit -F, rev-parse, interpret-trailers --parse --no-divider, config trailer.separators and cat-file commit for the written commit's trailer read-back -- exit 3 on an injected one, #273) | yes |
nen spec
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen spec number | the next free {nnn} in a spec repository: the highest taken on origin/<base> (as last fetched) or by an open PR's files, plus one; names a collision, picks no winner | git (rev-parse, ls-tree) under --repo; nen/workflow.json branch.base; github (gh pr list --json number,files); git remote get-url origin when no --target | yes |
nen spec check | a spec folder or the constitution held to citation-or-marker, plus Spec Kit analyze's computable passes (duplicate ids, placeholders, inferred tier in a MUST/SC, FR↔task both ways, the caller's vague terms) and the open markers ranked by clarify's taxonomy; CRITICAL exits 1 | spec.md/tasks.md or .specify/memory/constitution.md under --repo; the --vocabulary file; no git/gh | yes |
nen spec cite-check | every [src:] range in a folder resolves at its own sha in the member checkout the checkouts file names; excerpt hashes against capture/<CODE>/inventory.json; --at reports [STALE] candidates | the folder's .md files and nen/repos.json under --repo; the --checkouts file; git (remote get-url, rev-parse, cat-file) in each member checkout | yes |
nen spec index | <root>/INDEX.md regenerated from each folder's spec.md header; reports current / stale / hand-edited / absent; --write refuses over a hand edit | spec.md headers and INDEX.md under --repo; WRITES <root>/INDEX.md under --write unless --dry-run | yes |
nen spec inventory | one row per owned file fact of a member at a commit — {id, kind, path, lines, sha, excerptSha256, tier, ruleId}, no excerpts — from the build system's own membership (Xcode build phases and synchronized groups, Gradle include list and source sets, tsconfig files/include/extends/references) classified by the scenario handbook's capture-reader appendix; totals per kind, unknown never omitted | git (rev-parse, ls-tree, cat-file, remote get-url) in the member checkout; WRITES --out when given | yes |
nen spec diff | added, removed and changed rows by stable id between two inventories of one member, each changed field named; a different sha alone is no change, so identical inputs give an empty diff | the two inventory files; no git/gh | yes |
nen spec converge | a folder's citations of one member re-read at a newer inventory's sha: gaps missing · partial · contradicts · unrequested (against capture/<CODE>/inventory.json), ticked tasks listed as claims, never evidence; --write only appends [STALE @ <sha>] companions and one dated convergence phase, and a second run changes nothing | spec.md/tasks.md, nen/repos.json and capture/<CODE>/inventory.json under --repo; the inventory and --checkouts files; git (remote get-url, rev-parse, ls-tree, cat-file) in the member checkout; WRITES spec.md and tasks.md under --write unless --dry-run | yes |
nen spec coverage | capture form: covered/total per row kind per member and requirement↔task/test traceability both ways, each with its denominator; delivery form: every F<nnn>-SC-### of an issue has one ## Spec row in the PR body, satisfied with a passing test or deferred with a reason and a follow-up — an outside id exits 2 | capture: folders and nen/repos.json under --repo, the inventory files; delivery: the two body files and --test-report; no git/gh | yes |
nen spec parity | one row per FR and member from each folder's parity.md, each state held to what SP-6 says it carries (a citation, UX-13, a CL-nnn or PT ruling, both citations, the files searched), a missing row or column open; --target adds each row's live issues and PRs | parity.md/spec.md and nen/repos.json under --repo; github (gh issue list, gh pr list) with --target | yes |
nen spec tasks groups | tasks.md grouped by story and platform, each group's state (open, clarifying, captured, delivered) and dependencies in topological order, and per story group the dispatch title and an issue body quoting its scenarios as fenced source data | spec.md/tasks.md under --repo; git rev-parse HEAD for the pinned sha | yes |
nen spec trace | <root>/traceability.md for one family: per FR and SC, each member's parity state or citation count, the tasks and open markers; reports current / stale / hand-edited / absent and --write refuses a hand edit | spec.md/tasks.md/parity.md and nen/repos.json under --repo; WRITES <root>/traceability.md under --write unless --dry-run | yes |
nen decisions
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen decisions summary | rows per class and per gate and the G5 ids of nen/decisions.json, so prose never carries those numbers | nen/decisions.json under --repo | yes |
nen tests
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen tests map | each acceptance criterion of an issue body with the tests whose names carry its id (mapped · unmapped · unrequested); --require-red reads one run as the red checkpoint, --before-report reads two as red-first · green-only · failing · untested | the issue body and test report files (any shu test-report format); no git/gh | yes |
nen shu
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen shu detect | read the markers on disk and PROPOSE a nen/contract.json project block; never writes without --write and never overwrites one | the target repo's own files (framework configs, package.json, project files); writes nen/contract.json only with --write | yes |
nen shu build | compile or assemble a lane, from the invocation its declaration states | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu test | run a lane's test suite, from the invocation its declaration states | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu ui-test | run a lane's UI/E2E suite, from the invocation its declaration states | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu lint | run a lane's linter and format check, from the invocation its declaration states | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu typecheck | run a lane's static type check, from the invocation its declaration states | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu archive | produce a lane's distributable artifact, where its declaration states one | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu release | publish a lane's artifact, where its declaration states a publication step | nen/contract.json (project block); spawns the declared argv unless --dry-run | yes |
nen shu dev | start a lane's DEBUG build; long-running, on this terminal. With --target <name> it launches a declared DEVICE instead: the declared probe, the verb, then the target's after-steps | nen/contract.json (project block, plus project.launch for --target); inherits stdio unless --dry-run; spawns the declared device probe and after-steps only with --target | yes |
nen shu run | start a lane's PRODUCTION build locally; long-running, on this terminal. Takes the same optional --target | nen/contract.json (project block, plus project.launch for --target); inherits stdio unless --dry-run | yes |
nen shu deploy | send a build to a declared, NAMED target -- TWO flags and no single-flag path to acting: --target is required and has no default, --run is required before anything is sent, and a lane whose deploy is a seat refuses with its own reason whatever --target says | nen/contract.json (project block + project.targets: the destination's args, the env NAMES it requires, or the sentence saying it has no command line); spawns the declared argv only with --run | yes |
nen shu coverage | run a lane's coverage command and PARSE the report it produced into one shape -- totals, per-target rows, and --threshold's met, which never moves the exit code; --touched --base <ref> narrows the rows to the files a change touched (a git-diff read after the run) and, with --threshold absent, bands each row against nen/workflow.json's coverage ladder -- or, where that file is absent, nen's published 80/85/90 defaults -- instead; never gating either way | nen/contract.json (project block); spawns the declared argv unless --dry-run, then READS the report the verb's artifacts name (and, under --touched with no --threshold, nen/workflow.json through the shared loader) | yes |
nen shu test-report | run a lane's declared TEST command and PARSE the results it produced into one shape -- a row per test and the four counts. It declares nothing of its own: it runs project.verbs.<lane>.test and reads THAT row's artifacts, one file or a whole directory of XML | nen/contract.json (project block); spawns the declared test argv unless --dry-run or --from-artifacts, then READS the results the test verb's artifacts name | yes |
nen shu evidence | match git diff --name-status <base>...HEAD against project.evidence.globs, deriving each survivor's suite/scene and grouping suite -> scenes; empty is exit 0, never an error | git diff (through the seam only -- no declared invocation, no lane); nen/contract.json (project.evidence) | yes |
nen shu tools | check the host toolchain a declaration pins (exit 5 when anything is missing or wrong, exit 7 when nen is behind the dependency block's pinned_ref inside its minimum), and with --install use the closed corepack, Bashcov-only lane-local gem and general user-local gem-user modes | nen/contract.json (project.toolchain + dependency); spawns each declared version probe unless --dry-run; spawns an installer only with --install | yes |
nen shu warmup | warm a WORKING COPY: clean, fetch, fast-forward the trunk, cut the named branch, verify the declared build -- the one shu verb that mutates git state. Not nen warmup, which sweeps a registry and reads only | git in --repo (unless --dry-run); nen/contract.json (project block) for the build/test half | yes |
nen dev
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen dev test | run this checkout's own vitest suite via bun run test | package.json + vitest.config.ts under --repo | no (stdio) |
nen dev lint | run this checkout's own eslint via bun run lint | package.json + eslint config under --repo | no (stdio) |
nen dev replay | replay the imported dedupe corpus slice against nen's own normalizeTitle/findCanonical and report any disagreement | tests/fixtures/dualrun-slice/dedupe/*.json (or --slice-dir) | yes |
nen parse
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen parse <skill> | parse an arbitrary skill's invocation against a caller-supplied --grammar template, echo the parse, or refuse with a corrected line | none | yes |
nen parse futon | parse futon's own grammar and resolve its repo token against the target repo's nen/repos.json, refusing a 'then <terminal>' clause on a repo that is not the caller's own; reports an optional --idle (HR-5) and --dry-run (#520) | nen/repos.json | yes |
nen parse izanagi | parse izanagi's MUTATING-loop grammar, refusing when 'up to <N>' is absent | none | yes |
nen parse izanami | parse izanami's READ-ONLY-loop grammar and classify every command in it against izanami's own allow/refuse table | none | yes |
nen bootstrap
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen bootstrap | fetch, checksum-verify and cache a pinned nen binary by running bootstrap/nen.sh, relaying its verified path and exit code unchanged | bootstrap/nen.sh under --repo; network (GitHub release assets + SHA256SUMS) | no (stdio) |
nen wake
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen wake verify | scan open PRs whose author matches --author-pattern for a swallowed (action_required/startup_failure, never-executed) workflow run, auto-redriving what is safe and flagging the rest for a human | gh (pulls, actions/runs, issue comments; --run also writes reruns + comments) | yes |
nen wake fire | edge-trigger one object by removing then re-applying a label, then post an optional settle comment | gh (issue edit x2, api comment; --run required to write) | yes |
nen stop
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen stop | render the gate-stop banner plus a padded-markdown efforts table read from a file/stdin, or (--template) a blank table to fill in; --mark also records the stop for a host hook | a local efforts.md file or stdin; git rev-parse --git-common-dir under --mark. --mark WRITES .nen/last-stop.json under --repo and <git-common-dir>/.nen/marks/<effort>/<gate>.json; list reads both, clear removes them | yes |
nen stop answer | record the answer a stop received -- the question, every option with its consequence, and a picked key or the typed reply verbatim -- as one record with a never-reused id R-YYYY-MM-DD-nn; answer show lists an effort's records. Records, never chooses | git (rev-parse --git-common-dir); the --question-file/--typed-file under --repo; WRITES <git common dir>/.nen/stops/<effort>/<n>.json and <git common dir>/.nen/stop-ids/<id> unless --dry-run | yes |
nen exits
| Verb | Purpose | Reads | --json |
|---|---|---|---|
nen exits | every exit code above the shared 0/1/2 scheme, verb -> code -> meaning, read from the registry; USAGE's exit table is held to it | nothing outside the binary | yes |