AGENT SKILL

verbs

Every nemia verb you run, by who answers for it — a read, yours unasked, one that prompts the person, one that answers what waits on them — with its usage and help.

License 许可
MIT
所属仓库
emyann/nemia
最近更新
2026-11-15
Stars
★ 3
Forks
0

01 前言 Front Matter

name
verbs
description
Every nemia verb you run, by who answers for it — a read, yours unasked, one that prompts the person, one that answers what waits on them — with its usage and help.

03 SKILL.md 正文

The verbs

Every verb nemia serves you, by who answers for it, with its usage and help as nemia --help prints them. nemia <verb> --help says more of one that has a manual. With a shell, run nemia <verb>; on the MCP port, call the tool its on the port line names, whose schema says its arguments. A verb said CLI only runs at a shell alone, for the reason given.

Generated from the command table, never edited by hand: from the repository's root, node -e "import('./packages/agent-orchestrator/src/nemia/verbs.verb.ts').then((m) => process.stdout.write(m.verbsSkill()))" > packages/agent-orchestrator/nemia/skills/verbs/SKILL.md.

Reads

They write nothing: run them unasked, as often as you need. One that sets with some words prompts the person given them.

  nemia concluded <runId>
                               what a run started with --from <runId> would be handed of it, now
                               on the port: concluded
  nemia inbox
                               the cards still in play: name, first line, workflow when set,
                               and started as <runId>, <phase> (nemia inbox --help); --all: those whose
                               run ended too; -l: the cards whose labels match; --show-labels, -L <key>:
                               their labels on each line; -o wide: every column
                               on the port: inbox, inbox_card
  nemia factory
                               the store's factories: the default first — every run and card that
                               names no factory, read, never written — then each by name with its
                               repositories (nemia factory --help)
                               on the port: factory
  nemia factory ls
                               the same, by its name
                               on the port: factory_ls
  nemia factory diff <name> --to <x.y.z> [--template <name|folder|archive>] [--set <key>=<value> ...] | <name> --template <name|folder|archive> [--set <key>=<value> ...]
                               preview a templated factory's upgrade: what merges cleanly, and each
                               conflict with its sides; onto a template of another name, a switch
                               with no common base; or a hand-made factory's takeover by a
                               template, and the plan nemia factory adopt takes; nothing is written.
                               To change a parameter alone: --to the version applied, and
                               --set <key>=<value> for each; it prints the line that files it
                               on the port: factory_diff
  nemia factory servers <factory>
                               a factory's own MCP servers, each with the state its harness reports
                               on the port: factory_servers
  nemia factory rules <name> [--file <path>|- | --clear]
                               a factory's rules and policies: words told to every agent hired into
                               it, after its custom instructions and before the step's own note,
                               kept by the store with the factory. Bare, prints them; --file writes
                               them (- for stdin); --clear removes them. Words only: a frontmatter
                               block is refused. A run keeps the rules it was started with
                               reads bare; prompts the person given --file, --clear
                               on the port: factory_rules, factory_rules_put, factory_rules_delete
  nemia factory instruction <name> [--path <path> | --store | --clear]
                               where a factory's instruction is kept, what Nemia is to know of the
                               factory (its agents are told its rules: nemia factory rules): bare,
                               prints it; --path reads it from a file in the factory's first folder,
                               --store keeps it in the store, --clear reads NEMIA.md in the first
                               folder again
                               reads bare; prompts the person given --path, --store, --clear
                               on the port: factory_instruction, factory_instruction_put, factory_instruction_delete
  nemia template lint <folder|archive>
                               check a template's folder or archive: every problem at once, each at its
                               file and line
                               CLI only: a template is a folder on the machine nemia runs on; the board reads none yet
  nemia ls [<runId>] [-l <key>=<value>] [--show-labels] [-L <key>] [-o wide]
                               runs and their steps — a run waiting on another says waiting on <run>,
                               one the cap on runs in flight holds waiting for a run slot (2 of 2 in
                               flight); what each step's tries and the run have cost, where measured;
                               last, whether a nemia up ticks the store and when its last pass was;
                               first, while the store is paused, Pausing: N finishing and each
                               session, check or landing at work, or Paused once none is, then each
                               check it holds, a landing with its merge staged in the repository's
                               own working tree (MERGE_HEAD) among them; a step whose check it holds
                               says waiting on the pause. -l: the runs whose labels match (team=core,
                               given again for another); --show-labels: each run with its labels;
                               -L <key>: that label beside each run, given again for another; -o
                               wide: every column, each step among them
                               on the port: ls, ls_run
  nemia show <runId> [--raw]
                               the run as one object (nemia/v1 Run); --raw: its record, and
                               what each step was told
                               on the port: show
  nemia closeout <runId> <step> [--try <n>]
                               what a step's try signed off with: its latest, or --try <n>
                               on the port: closeout
  nemia logs <runId> <step>
                               that step's session output
                               on the port: logs
  nemia stats [--from <day>] [--to <day>] [--by agent|step|factory|workflow|repo] [--agent|--step|--factory|--workflow|--repo <v>] [-l <key>=<value>] [--line|--json]
                               what every run in the store adds up to, by UTC day: rounds to
                               acceptance of each loop: step, landings of the workspace: base step
                               and on which try, cost and time per landed run, and each step's
                               tries, time, cost, checks and gate waits; first the last 14 days
                               against the 14 before. A number nothing measured reads —, never 0.
                               --line: one line, for a recap; --json: the whole answer; -l: the
                               runs whose labels it takes, as nemia ls -l takes them
                               on the port: stats
  nemia passes [--last <n>] [--json]
                               what the recent passes of the tick cost: their median and slowest
                               time, a histogram of their times, where the time went phase by
                               phase, and what the last saw — the runs in the store, its journal
                               reads, the sessions queued and admitted. --last <n>: the last n
                               passes only; --json: the whole answer
                               on the port: passes
  nemia series [--range 24h|7d|30d|all] [--json]
                               the system's series over a range: a pass's time and its phases, its
                               journal reads, the runs in the store, the sessions queued and admitted
                               and the longest wait, the load, and the quota used. --range: 24h (a
                               point a minute, the default), 7d or 30d (an hour), all (a day);
                               --json: the whole answer
                               on the port: series
  nemia agents [--repo .]
                               the agents a step may name, the repository's then yours: what each is
                               for, what it says it can do (an entry for each skill, read off its
                               SKILL.md), and the skills it is given (its skills:)
                               on the port: agents
  nemia agents card <name> [--repo .] [--from repo|yours]
                               that agent in the shape of an A2A Agent Card, JSON on stdout and
                               nothing else — every field the protocol marks REQUIRED but
                               supportedInterfaces, which is left out because nothing here serves an
                               agent over A2A. The card describes; it is not an address
                               on the port: agents_card
  nemia agents sources [--path <folder>]
                               the agent files the store knows of, to copy into your library:
                               each repository's, yours, and those of a --path <folder>
                               on the port: agents_sources
  nemia agents custom <name> [--file <path>|-] [--clear] [--repo .]
                               your custom instructions for that agent: words you add to it without
                               rewriting it, kept in <store>/custom-instructions/<name>.md and told
                               after its instructions. Bare, prints them; --file writes them (- for
                               stdin); --clear removes them. Words only: a frontmatter block is
                               refused. A run keeps the words it was started with; nemia, the
                               store's own agent, is told them in her open session
                               reads bare; prompts the person given --file, --clear
                               on the port: agents_custom, agents_custom_put, agents_custom_delete, nemia_instructions, nemia_instructions_put, nemia_instructions_delete
  nemia wait [-l <key>=<value>]... [--from <cursor>] [--for <duration>]
                               wait for the feed's next line -l takes, and print it with the
                               cursor after it: from --from (a cursor a wait or nemia watch printed),
                               else from the feed's end now. It ends on the first lines -l takes, or
                               after --for (4m by default, at most 270s) with none, and prints the
                               cursor either way: wait again from it and no line is lost.
                               -l: as nemia watch -l takes it, given again for another; none takes
                               every line.
                               on the port: wait
  nemia level [manual|semi-auto|auto] [--factory <name> [--for <duration> | --end]]
                               Nemia, the store's own agent: bare, where she is, each factory's level and
                               how to reach her; a level sets the store's, which every factory follows
                               unless it has its own; --factory sets that factory's, --for raises it for
                               a stretch (90m, 2h, 1d; up to 7d) and --end ends the raise. semi-auto keeps
                               her session: what waits on you (a gate, a step's question, a loop out of
                               rounds, a cap) is asked of you, and a write that cannot be undone or
                               changes your settings or a factory; the rest is hers. auto is semi-auto,
                               but an answer your confirmed list allows in the run's state is given
                               unasked (nemia policy <agent>), in a session of hers filed since auto came:
                               one kept from before asks every answer until filed again (manual, then
                               auto once it is off). A factory at manual is left alone, and her session
                               stops once none is above manual
                               reads bare; prompts the person given manual, semi-auto, auto, --factory, --for, --end
                               on the port: level, level_set
  nemia memory [<fact>]
                               what Nemia keeps of the store: bare, her facts' names; given one, its
                               words. Read only: her session alone writes them
                               on the port: memory, memory_fact
  nemia policy <agent>
                               the agent's rules at auto: the answers it may give unasked, in force once
                               you confirm them, and what it proposed from your custom instruction,
                               with the words the machinery cannot hold, kept as guidance
                               on the port: policy
  nemia policy reach <agent> (--factory <name> | --run <runId>)
                               which steps at their gate the agent's rules in force could ever approve
                               unasked, in a factory or a run: why each other rule cannot (a step approved
                               before it runs has done nothing to recommend or check; one with no check
                               never passed one), what keeps a rule from a run now, and the rules that would
                               on the port: policy_reach
  nemia service status [--name <name>]
                               the login service and the lease: whether it is installed and runs,
                               the checkout it runs, who holds the store, and lingering
                               CLI only: it writes or reads the person's login services, on the machine the command runs on
  nemia service addresses [--json]
                               this machine's addresses, loopback first, one a line: the address, its
                               interface and its kind (loopback, private, shared, link-local,
                               unique-local, public), so --bind takes a private one; --json prints
                               {"addresses":[{"address","interface","family","kind"}]}
                               CLI only: it reads the network interfaces of the machine the command runs on
  nemia doctor [--json]
                               every piece this server needs before a run: each harness installed and
                               signed in, the service and its linger, the bind, the machine, the git
                               identity, each factory's workflows' and repository's needs, a factory, a
                               newer release — each in place or missing, with the command or fix that
                               puts it there. --json: the whole read
                               on the port: doctor
  nemia readiness
                               retired: nemia doctor reads what it read
                               CLI only: retired: nemia doctor is the read, served on the port
  nemia token ls
                               the tokens you minted, by name: who holds each, the factory and the
                               narrowing of an agent’s, and when it was minted. Never a token itself
                               on the port: token_ls
  nemia pairings ls
                               the pairings the store keeps, newest first: the client that asked, and
                               whether it waits for your approval, is approved, was claimed or lapsed.
                               Never a code: approve the one the client shows with nemia pairings approve
                               on the port: pairings_ls
  nemia claude-token status
                               whether your subscription token is kept, its file and its mode, when it
                               was set and the days left of its year, warned of a month before it ends:
                               never the token
                               CLI only: the token is the person's own, kept on the machine the store is on and read there from the terminal; no caller of the port reads or writes it
  nemia version [--json]
                               this nemia's release, an install's tag or a checkout, and its folder;
                               the release the store's releases/current names; and the release the
                               daemon runs, from its lease, and whether it promises to keep a running
                               session on its files; and the sessions at work by release and harness
                               version, off their records; and a newer release, where the daemon's
                               release check read one. --json: the whole answer
                               CLI only: it says which code the command runs from; the api answers its own at GET /api/version
  nemia admit [--at-least <level>] [--auto <agent>]
                               a call's admission: the call a session is about to make, on stdin, answered
                               ask where it answers what waits on you;
                               --at-least: deny a call acting on a run or a factory below the level;
                               --auto: let through, for a run of a factory at auto, an answer the agent's
                               rules you confirmed allow in the run as it stands (nemia policy <agent>)
                               CLI only: a session's hook asks it before each call, on its own machine
  nemia decide <runId> [--sensitive <globs>]
                               what the run produced, and the choice it leaves you (nemia decide --help)
                               on the port: decide

Yours

They write, and are yours to run unasked, on your judgement: say what you did.

  nemia start <brief.md|card|"text"> --workflows <name> [--repo .] [--no-worktree] [--after <runId> ...] [--from <runId> ...] [--input <file> ...] [--card <name> ...] [--gate <step> ...] [--model <step>=<model> ...] [--factory <name>] [--brief "<brief>"]
                               start a run of a workflow from a brief, a text, or a card of the inbox
                               --workflows <name>: the workflow, by its name, as its factory offers
                               it (nemia workflows lists them); a card's own workflow: where it names
                               one. A path to a workflow folder, and a folder of cards, are refused:
                               file each card (nemia inbox add <card>) and start it by its name
                               --after <runId>: file nothing of this run until nemia decide says that
                               run has landed — finished, and its result branch on the base
                               branch — and start from the base as it is then; once per run.
                               --from <runId>: hand this run what that run concluded, as context,
                               and wait on nothing: landed or still in flight, it is read once,
                               when this run's steps are filed, and said not landed, not judged
                               until it has landed; once per run.
                               --gate <step>: that step's closeout waits for nemia approve before
                               anything after it is filed, as a step's own gate: true does; once
                               per step. An inbox card's gate: <step> is one more
                               --model <step>=<model>: that step runs on the model in this run alone;
                               its other steps, and every other run, keep their agents' models. Once
                               per step, over an inbox card's model: for the same step. Refused, naming
                               the models that keep it, where the step's harness refuses the model or
                               its permission mode is dropped on it
                               a file that opens with a frontmatter block of workflow: and after: starts
                               its body, on its workflow: unless --workflows is given; its after: needs
                               an --after for each. Any other key is refused by its name, never taken
                               as the brief: file an inbox card with nemia inbox add <file>
                               --input <file>: copied into the run's own inputs/ directory, and named
                               on every step's brief under what was asked for; once per file
                               --card <name>: an inbox card, as nemia inbox lists it, copied as it
                               reads now into the run's inputs/cards/<name>.md and named on every
                               step's brief beside the files; once per card. A name with no card is
                               refused before anything is written
                               --factory <name>: the workflow must be attached to the factory, whose
                               hires fill its steps, and a step left with no agent is refused (nemia
                               factory --help). Without it, the run is started in the factory whose
                               repository holds --repo, else the daemon's own repository, when one
                               factory alone does; none, or two, is refused, naming the fix. In a
                               factory the run works on the repository it names for the workflow
                               (nemia factory attach <factory> <workflow> --repo <name>), else its
                               only one: --repo only finds the factory, and the start says so where
                               it differs
                               The default factory is history only: --factory default is refused
                               a card of the inbox (nemia inbox --help), by its name, starts its body,
                               or --brief "<brief>" in its place, and stays in the inbox, listed as
                               started: --workflows, a name, is its workflow: unless given, --factory
                               its factory:, and a card that names no factory either way is refused;
                               --repo is refused: its factory places the run
                               on the port: start, inbox_start
  nemia inbox add "<idea>"|<file> [--workflow <name>] [--factory <name>] [--label <key=value>]...
                               park an idea as a card in the inbox, named from its first line
                               on the port: inbox_add
  nemia inbox queue <name> [--workflow <w>] [--off]
                               mark a card to start on its own: the tick starts the oldest queued
                               card once a run slot is free; --off takes the mark back
                               on the port: inbox_queue, inbox_unqueue
  nemia inbox from <name> <run>... | --off
                               set the runs a card is handed as context (from:), read and
                               never waited on; --off takes them off
                               on the port: inbox_from
  nemia inbox edit <name> "<card>"|<file>
                               replace a card's body and keys with a card's text, typed or a file;
                               the card keeps its name, and its labels: nemia label inbox edits those
                               on the port: inbox_edit
  nemia label run <runId> <key=value|key->... [--overwrite]
                               edit a run's labels: key=value sets a key, key- removes it; changing a
                               value takes --overwrite. nemia ls -l selects by them, and the feed's
                               lines written after carry them
                               on the port: label_run
  nemia label inbox <name> <key=value|key->... [--overwrite]
                               edit an inbox card's labels: key=value sets a key, key- removes it;
                               changing a value takes --overwrite. nemia inbox -l selects by them, and
                               the run the card starts is created with them
                               on the port: label_inbox
  nemia route <runId> <condition> <route>
                               route a condition by hand: the next tick takes your route over the
                               condition's own answer, for the try it is on, and files the nodes
                               whose when: names it. Refused once a node after it is filed or sent:
                               nemia cancel <runId>, and start again.
                               on the port: route
  nemia refresh <runId> [<step>] [--base]
                               take the new revisions: a run keeps the workflow, agents, skills and
                               factory rules it resolved when it started, and this pins it to the
                               ones they hold now, so every filing after it — a new step, a retry,
                               a round — is filed on them. What has already been filed is not re-run,
                               and the steps the run has are neither added to nor removed. Refused of
                               a run that has filed nothing, which resolves afresh at its first filing
                               anyway, of one already on the newest revision of every kind, and of one
                               whose factory follows revisions (nemia factory revisions), whose every
                               filing takes them with no refresh;
                               --base: take the base instead — a loop's work that no longer merges
                               cleanly goes back to merge it, once, on the next tick, on the round it
                               is on, which the merge does not spend; the step is the one that closes
                               the loop, left out where the run has one loop
                               on the port: refresh
  nemia say <runId> <step> "<words>"
                               tell a step's running session something, through its harness: the
                               engine journals the words on the step's task, nemia ls notes the step
                               said to, and nemia decide prints them under it. A try that continues
                               the session is handed them again, as ## Said to your session.
                               Words to a step not filed yet (waiting on --after, a hold or an
                               earlier step) are kept, not delivered: its first try is handed them,
                               as ## Said before you started, and no try after it.
                               Words are from whoever holds the token sent: a session its run filed
                               speaks as its agent (WF_SESSION_TOKEN), an agent given a token of its
                               own (nemia token add <name> --agent <agent>) as that agent. An
                               agent's words reach the step under its name, never as yours
                               on the port: say
  nemia agents run yours <name> --brief <words>
                               an agent of yours tried on a short brief, in a folder of its own,
                               capped at $1
                               on the port: agents_run
  nemia hold <runId> [--until <runId> ...] [--why "<words>"] [--by <name>]
                               file nothing more of a run until other runs land, as --after would
                               have: what is in flight finishes, nothing new is filed, and nothing
                               is asked of you — nemia ls and nemia decide say held until <run> lands, and
                               what a step asks is asked once the hold lifts. The tick lifts it when
                               every run named has landed. With no --until, the run is held until a
                               person lifts it (--off), and no tick lifts it: nemia ls and nemia
                               decide say held until a person lifts it. Refused of a run cancelled,
                               pruned, finished or already held, and of a run named that is unknown,
                               the run itself, or one that already waits on it, through --after or a
                               hold.
                               --why: the reason, shown beside held until <run> lands wherever it is
                               said; --by: who puts the hold (default: your OS user).
                               nemia hold <runId> --off: lift the hold now, and the next tick goes on as
                               if it had never been put
                               on the port: hold, unhold
  nemia pause [--why "<words>"] [--by <name>] [--timeout <d> | --now [--yes]]
                               pause the store: no pass starts new work — no step, try, round or
                               check filed, no queued task admitted, no queued card started — and
                               every session, job or attached, parks at its tool call's end: a call
                               still in flight once the timeout has passed is cut. A check runs on, its
                               end recorded; a landing whose check has ended commits or aborts.
                               Pausing: N sessions finishing a tool call, cut in M min while they
                               do, Paused once none does; nemia ls says each step paused.
                               nemia start still writes a run, and approvals, retries and answers are
                               kept, not acted on: the pass after nemia resume files what waits. nemia ls,
                               nemia watch --once, nemia start and nemia up say it, and nemia ls names what finishes.
                               Refused while a pause stands.
                               --why: the reason, said wherever the pause is; --by: who pauses it
                               (default: your OS user)
                               --timeout: how long a call in flight is given to end, for this pause
                               (90s, 10m, 2h; from 1s to 23h); default: the store's, nemia pause-timeout
                               --now: pause at once, the board's Stop now — each step session at work,
                               but a landing's, has its call cut at once and parks, going on as the
                               same try on nemia resume;
                               each check is asked to stop and run again. A pause that stands is kept.
                               --yes: with --now, act; without it, --now only says what it would
                               cut
                               on the port: pause
  nemia resume
                               resume the store: each session parked goes on as the same try, and the
                               next pass files what waits
                               on the port: resume
  nemia subscribe <name> <task> [-l <key>=<value>]... [--digest-every <minutes>] [--at-least <level>]
                               give the engine's long-lived task <task> a subscription to the feed,
                               named <name>, from its end: a line one of its selectors takes is said to
                               it at once, and the rest folded into a digest said with the next wake,
                               or after --digest-every minutes (default 60) with none.
                               -l: the lines it takes, given again for another (default:
                               waits=person, the lines that wait on a person). Refused for a task not
                               long-lived.
                               --at-least: only the lines of runs whose factory's level is at least
                               this (manual, semi-auto, auto), read as each line is delivered.
                               on the port: subscribe
  nemia unsubscribe <name>
                               take the subscription <name> away: its task is told nothing more of the feed
                               on the port: unsubscribe
  nemia policy propose <agent> --file <path>|-
                               the agent's proposal: rules from your custom instruction, as JSON,
                               with the words the machinery cannot hold kept as guidance; none is in
                               force until you confirm it (nemia policy confirm)
                               on the port: policy_propose
  nemia daemon [--json]
                               the store's daemon, started where none ticks it (as any command that
                               ticks starts it, unless NEMIA_DAEMON_START=off): its state, its pid and
                               the url the api serves at, from its lease. --json: the whole answer
                               on the port: daemon

Prompts the person

Each asks the person at a prompt every time it runs: say what it does before you run it.

  nemia inbox rm <name>
                               drop a card without starting it
                               on the port: inbox_rm
  nemia factory add <name> --repo <path|url> [--repo <path|url> ...] [--no-trust]
                               file a factory: a lowercase slug naming one or more directories or git URLs,
                               each URL cloned, each trusted for its steps unless --no-trust
                               on the port: factory_add
  nemia factory apply <name> --template <name|folder|archive> --repo <path|url> [--repo <path|url> ...] [--set <key>=<value> ...] [--no-trust]
                               make a factory from a template that passes its check, its parameters
                               given with --set; the daemon renders its tree
                               on the port: factory_apply
  nemia factory adopt <name> --template <name|folder|archive> [--set <key>=<value> ...] --plan <digest>
                               take a hand-made factory over by a template, in place, as nemia factory
                               diff previewed it: its name, cards, runs and stats stay
                               on the port: factory_adopt
  nemia factory upgrade <name> --to <x.y.z> [--template <name|folder|archive>] [--set <key>=<value> ...] [--plan <digest>] [--downgrade]
                               upgrade a templated factory: its file wants --to, and the daemon merges
                               the template's change into its tree once each conflict is resolved;
                               with --to the version applied and --set, a change of its parameters
                               alone, filed with the --plan nemia factory diff printed for it
                               on the port: factory_upgrade
  nemia factory resolve <name> <conflict> --ours|--theirs|--file <path>
                               choose for one conflict of a templated factory's upgrade or switch: your
                               tree, the template (none: drop the file), or the text of a file; once
                               each conflict of a workflow, an agent, a skill, a hire or the rules and
                               instruction has one, that object is proposed as they compose it, to
                               approve (nemia proposals approve <p> -n <name>); a carried file stays
                               a choice; the daemon merges once each has one and each proposal applied
                               on the port: factory_resolve
  nemia factory attach <factory> <workflow> [--repo <name>]
                               offer a workflow in a factory, by its folder's name: a factory offers
                               only the workflows attached to it; --repo names the repository its runs
                               work on, by folder name, required where the factory has several
                               on the port: factory_attach
  nemia factory detach <factory> <workflow>
                               take a workflow back, once no hire fills its steps
                               on the port: factory_detach
  nemia factory hire <factory> <agent> --step <workflow>/<step>
                               hire an agent into a workflow's step: one a step, a second replaces it
                               on the port: factory_hire
  nemia factory fire <factory> --step <workflow>/<step>
                               take a step's hire back
                               on the port: factory_fire
  nemia factory schedule <factory> <workflow> --cron <expr> --brief <text> [--tz <zone>]
                               start a run of an attached workflow at each fire of a cron, by the
                               daemon, at every level; a second replaces the first
                               on the port: factory_schedule
  nemia factory unschedule <factory> <workflow>
                               take a workflow's schedule back: the daemon starts it no more
                               on the port: factory_unschedule
  nemia factory server add <factory> <server> --url <address> [--transport http|sse] [--header <name>=<value> ...] [--client-id <id>] [--callback-port <port>]
                               record a remote MCP server for a factory: its steps' sessions are
                               handed it, and an agent `mcp:` line names it
                               on the port: factory_server_add
  nemia factory server rm <factory> <server>
                               take a server off a factory's record
                               on the port: factory_server_rm
  nemia factory volume add <factory> <path>:ro|:rw
                               mount a folder of this machine for every local step of a factory's runs,
                               read-only (:ro) or writable (:rw); a writable one is not a run's workspace
                               on the port: factory_volume_add
  nemia factory volume rm <factory> <path>
                               take a volume off a factory, by its path
                               on the port: factory_volume_rm
  nemia factory setting set <factory> <harness>.<key> <json>
                               give every session of a factory's runs on a harness one of its settings,
                               claude.attribution among them; its value is JSON
                               on the port: factory_setting_set
  nemia factory setting rm <factory> <harness>.<key>
                               take a harness setting off a factory, by its key
                               on the port: factory_setting_rm
  nemia factory cost-line set <factory> <workflow> <usd>
                               set what a run of a workflow may cost before its gate says so, in dollars:
                               a gate whose caps pass it is said, and never approved unasked at auto
                               on the port: factory_cost-line_set
  nemia factory cost-line rm <factory> <workflow>
                               take a workflow's cost line off a factory
                               on the port: factory_cost-line_rm
  nemia factory instruct <name> --file <path>|- | --clear
                               write the instruction the store keeps for a factory (- for stdin), what
                               Nemia is to know of it and no step is told, or remove it with --clear
                               on the port: factory_instruct, factory_instruct_delete
  nemia factory revisions <name> follow|pinned
                               whether a factory's runs follow merged revisions at each filing (follow)
                               or keep them until nemia refresh (pinned, the default)
                               on the port: factory_revisions
  nemia factory trust <name>
                               trust a factory's places for the harnesses its steps run on, so each
                               place's own settings apply to them
                               on the port: factory_trust
  nemia factory rm <name>
                               remove a factory's file, and the instruction and the rules the store
                               keeps for it
                               on the port: factory_rm
  nemia template export <folder> --from <repo> [--factory <name>]
                               write a template from a repository and a factory, and say where each
                               part came from
                               CLI only: a template is a folder on the machine nemia runs on; the board reads none yet
  nemia template pack <folder> [--out <file>]
                               pack a template's folder that passes its check into one archive, and print
                               the digest of its content
                               CLI only: a template is a folder on the machine nemia runs on; the board reads none yet
  nemia template unpack <archive> <dir>
                               write the folder a template's archive holds at <dir>/<name>, each file's
                               bytes and mode as packed
                               CLI only: a template is a folder on the machine nemia runs on; the board reads none yet
  nemia agents write (yours | factory) [<name>] --file <name>.md [--factory <name>] [--version <v>]
                               an agent of yours, or of a templated --factory, written from its file:
                               <name> is the agent it changes or renames, at the --version it was
                               read at; none, a new one
                               on the port: agents_write, agents_replace
  nemia agents copy <file> [--as <name>] [--keep <part>]...
                               an agent file copied into your library, with its schema and skills;
                               a part your library holds otherwise stops it: --as or --keep
                               on the port: agents_copy
  nemia agents rm yours <name> --version <v>
                               an agent of yours removed, at the --version it was read at
                               on the port: agents_rm
  nemia skills write (yours | factory) [<name>] --file <SKILL.md> [--factory <name>] [--version <v>]
                               a skill of yours, or of a templated --factory, written from its
                               SKILL.md: <name> is the skill it changes, at the --version it was
                               read at; none, a new one
                               on the port: skills_write, skills_replace, skills_copy
  nemia cancel <runId>
                               stop what it has in flight; file nothing more
                               on the port: cancel
  nemia rm <runId> [<runId> ...] [--delete-branches [--force-unmerged]]
                               forget runs that are over, a line each: a run's worktrees removed
                               through git, what one held uncommitted committed first, then its
                               record and every file under WF_ROOT keyed by its id. Refused while
                               a task of it is in flight, anything is due to be filed or asked
                               for, or a run waiting on it has not started. Its branches are kept:
                               --delete-branches deletes those merged into the run's base branch,
                               and --force-unmerged beside it the others, with their work. Then
                               the engine forgets the run's tasks: their journals and session
                               files; one not settled yet is forgotten by the next passes
                               on the port: rm
  nemia prune [<runId> ...] [--unmerged] [--artifacts] [--yes]
                               free the space runs that are over hold: their worktrees, removed
                               through git, and nothing else — each run's record, branches and
                               files are kept, and it stays on nemia ls, nemia decide and the board,
                               marked pruned. --artifacts removes its files too (runs/<id>/
                               artifacts/: screenshots, logs), of a run whose worktrees are
                               already gone as well; its record and branches are still kept.
                               Lists what it would remove, with its size, and removes it on
                               --yes, or on y at the prompt. With no run, every run. Refused
                               while a run is not over, owes a hand-off, is a folder run, or has
                               a worktree held, on no branch, or with changes no commit has;
                               and a finished run not merged unless --unmerged, with --artifacts
                               as without: its files are what a person reads to decide it
                               on the port: prune
  nemia pause-timeout [<d>]
                               the store's pause timeout: how long nemia pause, nemia service restart and
                               nemia upgrade give each tool call in flight to end before it is cut; bare,
                               the timeout in force (10m by default); given one, sets it: digits and s, m
                               or h, from 1s to 23h, as 90s, 10m or 2h. nemia pause --timeout <d> gives one
                               pause a timeout of its own
                               on the port: pause-timeout, pause_timeout_set
  nemia policy confirm <agent> <id> --words '<words>'
                               put in force a rule the agent proposed, or the default again, as its
                               words read: from then on, at auto, the answer it names is given unasked
                               where it holds. Refused once the rule reads otherwise. Your first confirm
                               keeps the default beside it. Asked of you every time
                               on the port: policy_confirm
  nemia policy rm <agent> <id>
                               take a rule out of force, the default among them: what it allowed is
                               asked of you again. Asked of you every time
                               on the port: policy_rm
  nemia service install [--env KEY=VALUE ...] [--size auto] [--bind <addr> [--public]] [--name <name>] [--take-over <pid>]
                               install the daemon as a login service: a systemd user unit on Linux,
                               a launchd agent on macOS. It runs the api of this checkout with this
                               node, WF_ROOT and PATH, and each --env, written once; it restarts on
                               failure and starts at login. Started now unless another daemon holds
                               the store; --take-over <pid> pauses the store, waits for the calls
                               in flight of its sessions, stops that pid and starts the service
                               (checks and jobs run on, as nemia service restart --help says).
                               --size auto: the sessions at once and each one's memory limit and
                               request, read off this machine (WF_MAX_CONCURRENT, WF_MEMORY_LIMIT,
                               WF_MEMORY_REQUEST; neither memory one on macOS), each but one --env
                               gives; the floor kept, WF_MEMORY_RESERVED, is its default (an eighth
                               of the machine, 1 GiB at least). On systemd it also writes
                               <name>-sessions.slice, its MemoryMax at the machine less that floor,
                               and points WF_CGROUP_PARENT at it, so the sessions together are
                               held to what the machine allocates (none written where --env gives
                               WF_CGROUP_PARENT: a line names its set-property). --bind <addr>: the
                               address the daemon listens on (NEMIA_BIND), and the store marked
                               exposed (WF_EXPOSED=1), so every caller presents a token: nemia
                               pairings approve and nemia board link hand out the first. A public or
                               wildcard address is refused unless --public acknowledges it
                               (NEMIA_BIND_PUBLIC=1); nemia service addresses lists this machine's.
                               --name: the service name (nemia; required for a store that is not
                               the default)
                               CLI only: it writes or reads the person's login services, on the machine the command runs on
  nemia service uninstall [--name <name>]
                               stop the login service, disable it and remove its file and the
                               sessions' slice --size auto wrote; a daemon started by hand is left
                               alone
                               CLI only: it writes or reads the person's login services, on the machine the command runs on
  nemia service restart [--name <name>] [--timeout <d>]
                               restart the service's daemon on the code it runs: pause the store, give
                               the daemon's sessions up to the timeout to end their tool calls
                               (--timeout <d>, else nemia pause-timeout, 10m by default), stop it (up to
                               90s, and until the unit has ended its process), start the service (up to
                               60s), and resume once the new daemon has completed its first pass;
                               refused, naming the log, when that pass fails, and naming the command
                               that starts the service when it is not running.
                               Jobs and checks, a landing waiting on CI among them, run on and are not
                               waited for; each session parks and resumes as the same try. Each wait is
                               said on stderr as it waits. A pause a person put stands; the restart's
                               own ends with the command: killed, the next pass of the daemon lifts it.
                               Starts the service where nothing ticks; a daemon started by hand is
                               named with --take-over's line
                               CLI only: it restarts the person's login service, on the machine the command runs on
  nemia upgrade [<tag>] [--repo <path>] [--name <name>] [--timeout <d>]
                               on an archive install, download the tag's archive (the newest where
                               none is named), check it against its SHA256SUMS and run its nemia
                               version, into the store's releases/<tag>; on a release built from a
                               repository, build the tag from a clean export into releases/<tag>:
                               npm ci, npm run build and npm run release:check there, on a trial
                               store; then point releases/current at it and restart the daemon onto
                               it where the login service runs the pointer: jobs run on, and the
                               daemon's sessions are given up to the timeout to end their tool calls
                               (--timeout <d>, else nemia pause-timeout), park, and resume as the same try on
                               the new release; then say each piece the new release reads missing
                               that a run waits on, and each of the machine and its service, with
                               its fix, or that none of those is. A tag built already is switched
                               to without a rebuild, so an older tag rolls back. --repo:
                               the repository the tag is in (the running release's source);
                               --name: the service (nemia). Then it removes each release that is
                               not current, not among the two newest, and that no session or
                               running nemia runs on, the folder of each build whose upgrade died,
                               and each build log older than 30 days, as the daemon does every five
                               minutes. A tag older than the oldest release that can read the store
                               (store.json) is refused before anything is fetched or built. It
                               upgrades this machine's install, whatever the context: the server a
                               context names is upgraded from here with nemia server upgrade [<tag>],
                               through its api (not nemia service, this machine's login unit)
                               on the port: upgrade
  nemia frontmatter rewrite [<folder>...] [--check]
                               rewrite as YAML each markdown file's frontmatter still in the former
                               line form, under the folders given or the store's own. --check: write
                               nothing, and exit 1 where a rewrite is due
                               CLI only: it rewrites files on the machine nemia runs on, folders a person names among them
  nemia workflows write (yours | factory) <name> --folder <draft> [--factory <name>] [--version <v>]
                               a workflow folder of yours, or of a templated --factory, written from
                               a draft folder, its steps, README, scripts and schemas, leaving a file
                               it does not carry; one there already, at the --version it was read at
                               on the port: workflows_write, workflows_replace
  nemia workflows rm yours <name> --version <v>
                               a workflow folder of yours removed, at the --version it was read at
                               on the port: workflows_rm

Answers what waits

Each answers what waits on the person. Bring the matter first, with the bring-what-waits skill, then run the verb they choose, at a shell with their words as --message, or its tool on the port with them as its message: its prompt is their decision, asked once. retry asks only of a step that waits on the person, or with --budget.

  nemia retry <runId> [<step>] [--continue | --fresh | --model <m> | --recheck | --round] [--answer <n>=<letter>]... [--message "<answer>"] [--budget <amount>]
                               try a step waiting on you again, once, on the next tick:
                               --continue (default) continues its session, told what happened;
                               --fresh a new session on its branch; --model <m> the same, on m;
                               --recheck runs its check again, and files no session;
                               --round: once more — a loop out of rounds goes round again, once,
                               the step it loops to continued, then a new reviewer; the step is the
                               one that closes the loop, left out where the run has one loop;
                               --message "<answer>" goes into the try's brief, as ## Your answer:
                               for a step that signed off blocked, the answer to its needs — or
                               what you have to say to any step you try again; not with --recheck
                               or --round. The next argument is the answer, whatever it starts with;
                               an answer that is only one of these flags' names goes as --message=<answer>;
                               --budget <amount>: for a step with a budget that waits on you, its
                               cap raised to that many dollars, above its cap and what it has cost;
                               with --round, the cap of a step of the loop over its budget;
                               --answer <n>=<letter>: answer question n, numbered as nemia decide
                               <runId> prints them, with the option its letter names; once for each
                               question: "<n>=a,c" chooses several where it takes several,
                               "<n>=a: <words>" adds your own words, "<n>: <words>" says words
                               alone; --message is then the note under your answers
                               on the port: retry
  nemia approve <runId> [<step>] [--answer <n>=<letter>]... [--budget <step>=<amount>]... [--message "<words>"] | <runId> <step> --off
                               let a step waiting at its gate hand on: what waits on it is filed on
                               the next tick, and every step after the gate is handed your words
                               under ## Approved. To send it back instead, with what to change:
                               nemia retry <runId> <step> --message "<objection>"
                               Of a loop out of rounds — the step that closes it, or the run alone
                               where it has one loop — enough: the loop ends on your words, with its
                               findings open, --message "<why>" required. What waits on the looping
                               step is filed as if it had said again: false, and every step after
                               the loop is handed your words and those findings, under the heading
                               of a loop ended as it stands.
                               To go round once more instead: nemia retry <runId> [<step>] --round
                               --answer <n>=<letter>: answer question n, numbered as nemia decide
                               <runId> prints them, with the option its letter names; once for each
                               question: "<n>=a,c" chooses several where it takes several,
                               "<n>=a: <words>" adds your own words, "<n>: <words>" says words
                               alone; --message is then the note under your answers
                               --budget <step>=<amount>: the cap of a step after the gate, in
                               dollars, over what the step proposed for it; once for each step.
                               Your approval makes the budgets the step proposed the caps of the
                               steps after the gate, and auto never approves unasked a cap above
                               a step's own budget
                               --off: take back the approval of a step that stands approved while
                               nothing it approved has been filed — an ending waiting on the base
                               branch, held, or not yet ticked. The step waits at its gate again
                               on the port: approve

04 同仓库更多 Skills

emyann
emyann/nemia

groom-the-inbox

Read each card in play in the inbox against the repository and say, per card, done (the commit on the base that landed it), replaced (the decision or card that did), stale (each fact that moved, what it said and what it says now) or standing, reading closely only what the period touched. For the janitor's step, which proposes and never acts: a person removes or amends each card by the command the check writes.

★ 3
emyann
emyann/nemia

write-a-spec

Turn an accepted intent into a spec an engineer can build from in this repository: the goal restated, the approach and why, every path it touches, the steps, the tests that prove it, the risks, and what is still open. For a step that designs a change before anyone builds it.

★ 3
emyann
emyann/nemia

review-a-change

Review a change in this repository as a second engineer would: against its intent and spec, by reading the diff and the suite's verdict, with findings that name the file, the line and what goes wrong. For a read-only step that decides whether the work goes round again.

★ 3
emyann
emyann/nemia

read-the-stats

Read a factory's stats since the janitor's last run, against the same length of time before it, write a short report, and propose one correction per card — an allow or deny by name, a line in an agent's body or a skill, or a refusal kept on purpose — each with the numbers behind it, never one already in the inbox. For the janitor's step, which proposes and never acts.

★ 3
emyann
emyann/nemia

land-a-branch

Land a run's result on the base branch in this repository's own checkout, the way the step says it lands: make that one act, read its result, and write the message that records what landed — or change nothing and say why it refused. For a gated ending step (workspace: base).

★ 3
emyann
emyann/nemia

implement-a-change

Build a change from its spec in this repository: tests first where a rule is claimed, small commits, the tests of what changed green for the right reason, and each review finding answered in the next round. For a step that writes the code.

★ 3