The commands — the palette, every door

Generated from skills/ — the same files the plugin installs, one folder per verb. Each is a door to a flow that exists anyway; anything a command does, a sentence reaches.

/opsinist:advisor

Use when the user wants to build or run a team of AI agents out of one git repository — you act as their advisor (the skill ships under the name Opsinist); you interview progressively (defaults everywhere, small jobs stay small), keep every entity as a file (roles, tasks, teams, pipelines, requests, runs), dispatch agents against those files, and stay their console for status, cost, recovery, shipping and reshaping the team. Also for joining an existing repo, importing a backlog, or answering a question with no machinery at all.

The front door: the corpus itself — the laws, the routing table and what to load when. Every verb below loads it before running its flow, and a bare greeting or a described situation reaches it without naming a command at all. Read it in full on The skill.

/opsinist:audience

Ask the audience — personas built and consulted with the signal pyramid kept honest.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./audience.

Live, twin, validated persona, proto — never pooled: synthetic runs surface angles and never become percentages.

/opsinist:automate

A recurring job becomes an automation with a real trigger, or an honest manual one.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./automations.

A job that repeats gets a trigger the runtime actually fires — or is recorded as manual with its cadence, never as an automation that silently never runs.

/opsinist:consult

A question, not a thing to build: an answer, and nothing put into your project.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./consulting.

A question, not a thing to build: an answer, and nothing put into your project.

The answer ends in one named thing — a pick, a found item, a number — never in a set of options handed back. The three shapes are in templates/ANSWER-template.md.

/opsinist:cost

What work cost — measured at the run, summed, with the leaks named.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./cost.

Cost is measured once at the run and summed from the record; cache reads counted apart, and the trend reported, not just the level.

/opsinist:decide

Run one decision loop: frame, search, compare, choose, check, record.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in SKILL.md.

Every real decision runs the one loop — framed, searched live rather than recalled, compared with sources, chosen with its why, checked against being wrong, recorded in docs/DECISIONS.md.

/opsinist:decompose

Cut a feature into tasks — each workable from itself, with the seams named.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./decomposing.

Work is cut where the seams are: each child workable from itself, its outcome writable, and no two children of one wave owning the same file.

/opsinist:fire

Park or offboard a role — archived with a note, never deleted.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./hiring.

A role that has gone quiet is parked, not fired: archived with a note so its history survives. Offboarding changes the shape of the team, so it routes to the owner.

/opsinist:hire

Grow the roster — a role born from a need, hired with its bars and budget.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./hiring.

A role is hired when work demands a competence the roster lacks: written as a file with its grade, its bars and what it owns. Hiring changes the shape of the team, so it routes to the owner.

/opsinist:import

Bring work in from anywhere — a tracker, a spreadsheet, an export, a paste: mode declared once, mapping shown first, items created unassigned.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./importing.

Bring work in from anywhere — a tracker, a spreadsheet, an export, a paste: mode declared once, mapping shown first, items created unassigned.

/opsinist:init

Start or continue a project — empty folder or not is read, never asked; then the first task.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./arriving.

Start or continue a project. Whether a repository is here, whether it is yours, and whether it is empty are read from the ground, not asked — that is what decides between standing one up, entering it as its operator, and entering it as a guest.

Called bare — /opsinist init with nothing after it — this is a greeting, and the front door handles it: read what is here, say which entrance you would take and why in one line, and take it. Anything after the name is treated as what you would have said in a sentence, so /opsinist init a podcast about interest rates and "set up a project for my podcast" reach the same place.

/opsinist:join

Take over a repo that already exists — guest or successor read from the ground, the audit before any touch, findings as one classified list, fixes in batches the owner approves.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./entering.

Take over a repository that already exists. Guest or successor is read from the ground, not asked; the audit comes before anything is touched; findings arrive as one list, not one per message, each blocking or deferrable with the consequence named; deferrable ones land in ./later with a revisit trigger that is a moment, not a date; nothing is fixed before the owner has seen the list.

/opsinist:map

The product as a map: the moves through it, in its own words — not the file tree.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./mapping.

How the product is walked and what it is made of, in the product's own words; every node names something that exists, and the roadmap points at nodes — it never draws on the map.

/opsinist:migrate

Move a project between machines or runtimes — the repository travels, sessions do not.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./migrating.

End the session properly and open the project elsewhere: the record, roles and history are already there; what the old runtime held and the repo did not is re-created, not migrated.

/opsinist:recover

Read state back from the record and continue an interrupted run.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./recovering.

Recovery reads committed state, not a session that no longer exists: what was running, what it had produced, and where it stopped.

/opsinist:report

Something went wrong or made the work harder — recorded where it belongs, and if it is the skill's own defect, packaged into a file you can send.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./self-maintenance.

Something went wrong, or made the work harder than it needed to be. You do not have to know whose defect it is — that is the first thing this decides, and it decides it from the evidence rather than asking you to classify your own frustration.

Friction in your project becomes a field note in docs/FIELD-NOTES.md, one line, swept at the next status check; a second occurrence earns a task with both occasions named. Friction in the skill operating it is assembled from evidence — version, flow, symptom, the run record, the state of the files involved — de-identified, and written whole to a file outside your repository, with its path said out loud and the ways to send it named. Publishing is yours: the file is made here, you post it.

/opsinist:review

Call another craft to look — a request with a status and an age.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./requests.

A finished piece goes to someone other than its author: a request that is visible, ages honestly, and blocks what depends on it.

/opsinist:ship

A release: the batch, the guards, and the door it ships through.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./shipping.

Batch, do not drip: what ships, what its guards say, what changed for whoever upgrades — and the pages that describe it regenerate in the same act.

/opsinist:skill

The skill lifecycle: create from a routine, screen an import, compress, extract.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./skills.

A routine repeated twice becomes a skill; an imported one is screened before it attaches; a bloated one is compressed fail-closed; one that earned its keep across two projects is extracted.

/opsinist:status

The health check: what runs, what waits, and what has aged past its promise.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./checking.

What is running, what surfaced as ready and waits, which pending decisions show their age, and what the wait costs — and any work that outgrew its container, each seam ending in a named offer, never in an open question.

/opsinist:upgrade

Move the machinery to a newer version, with the migration named.

Load the opsinist skill (SKILL.md) and run this flow — the procedure is in ./upgrading.

What changes, what to run, what it touches, and what could go wrong — an upgrade ships with its migration map or it waits.