sessions

work — general-purpose work across the fleet, not just code. `/work:loop` is the unattended multi-project drain: spreads load with agents teams + balanced accounts, uses browser/computer/secrets for non-coding, drives each item to landed, merging engineering PRs on green behind a non-author review. Its `triage` mode (`/work:loop triage`) instead forces every open board item to keep-and-schedule-this-cycle or cancel, never a hedge state. `/work:dispatch` is ONE unit of work (coding or not) routed to the right executor. `/work:demo` (top-level alias `/demo`) is the post-ship capstone: recover the original intent, exercise the shipped thing in its REAL environment on real representative inputs signed in as the owner, put before/after side by side with a measured delta, and deliver an analyzed report. Kind-agnostic layer above `code:loop`.

self — operations an agent performs on its OWN session. `/self:close` cleanly self-terminates the current session by SIGTERM-ing the harness (the Bash tool shell's own parent, $PPID), after a read-only `ps` guard that refuses infra parents (shell/tmux/sshd) so it never tears down the wrong process. It is the low-level exit primitive: for a recap first use `/recap`, and to drive the current task to delivered use `/finish`. The exact `kill -TERM $PPID` form is allowlisted by the `self` permission group so it runs headlessly without an auto-mode prompt.

Coding-workflow plugin for the manager/router engineering loop. `/code:loop` drains a queue end-to-end (single ticket or many: plan, code, test, review, rebase, fix CI, merge) with verification folded in inline. `/code:review` is one skill, three modes: default recaps the session and lands every PR it opened, PR number(s) get a deep cold sub-agent review with file:line grounding, an architecture rubric (reuse of primitives, cross-cutting at the source, no duplicate surfaces, doc-asserted invariants), and a security pass on risk-touching diffs, and `repo`/a path/`--since` runs a read-only whole-repo architecture-and-quality scan with an HTML report — never a merge verdict. `/code:learn` learns a codebase and writes durable navigation notes into the project's own AGENTS.md, and only secondarily routes a genuine coding-workflow lesson back into this plugin. `/commit` splits the working tree into the maximum number of small logical commits. `/code:review` spawns the repo's `code-reviewer` subagent (shipped from the top-level subagents/ layer, not from this plugin) for the non-author review. Publishing a distributable (extension, CLI, web app) lives at the top-level `/release` command, not here. `/code:refactor` is the architectural restructuring a product needs as it grows: it builds a module dependency graph (god modules, cycles, package-extraction candidates, upward imports), measures which files agents actually read and edit from the fleet session index, censuses the public surface, and verifies the repo's own architecture claims against the code. It ranks seven moves — merge redundant concepts, extract the horizontal layer, draw the module boundary, lift a package/SDK out, reorganize the tree, shrink the surface — by harm x exposure, sequences them (cycles first, tree moves last), renders before/after architecture figures with artifacts-cli where every box and arrow is sourced from the graph JSON, and lands behavior-preserving PRs. It also judges whether a concept has the CONTRACT its job calls for — a family dispatched on by name across many files usually wants the provider pattern (one interface, one implementation per variant, one registry), and `patterns.ts` reports contract/registry presence, collapsible branch count, capability holes, and an in-repo exemplar to copy. Hygiene (dead code, doc drift, oversized files) is the byproduct tier, not the job. Its `quality` mode (`/code:refactor quality`, the door it shares with the global `simplify` skill) is the small, in-flight cleanup pass: fix a duplicate, a bad abstraction, or a pattern that should exist but doesn't, always tied to a concrete change.

Curated upstream config for agents-cli users

fleet — fleet-wide operations across every machine registered with `agents devices`. `/fleet:sync` pulls every registered DotAgent repo (system, user, and extras) to origin latest on every online device, then refreshes the installed agents — non-destructive (git merge --ff-only only; reports repos blocked by local edits instead of clobbering), handling the fast-forward workaround, the transient GitHub-SSH throttle, and Windows PowerShell quoting, ending with a repo x device matrix. `/fleet:onboard <device>` brings a bare new device up to fleet parity (agents-cli, agent CLIs, DotAgent repos, shared SSH key, PATH shim, device registration) and mints its agent auth in the same flow — the token-minting recipes are folded into the command itself. Discovery-first, additive, idempotent, credentials via sanctioned paths only, never copied host-to-host.

share — publish an HTML artifact (a plan, viz, or report) to a shareable link on your own Cloudflare R2 (zero egress, ~$0) via `agents artifacts share`. `/share` posts a public link with an auto-generated OG cover (a screenshot of the page's hero) so it unfurls into a preview card in Slack/iMessage/Twitter/Discord; `/share --private` posts an unlisted, auto-expiring (`--no-cover --expire 7d`) link with no preview card (unguessable but still public-read — not authenticated). Requires a one-time `agents artifacts setup` (provisions an R2 bucket + Worker) or `agents artifacts share join`.

swarm — fan a task out across parallel coding agents via `agents teams`. Top-level `/swarm` (and `/swarm:run`) is the generic fan-out. Specialized modes: `/swarm:plan` (change proposal + mandatory mock-ups + blind verification), `/swarm:spec` (durable source-of-truth contract so others do not invent wrong behavior — requirements, scenarios, mock-ups, drift-check), `/swarm:debug` (blind multi-provider root-cause). Shared engine: internal `swarm:orchestrate` skill. Commands only invoke skills. `/swarm:test` and `/swarm:qa` removed.

design — a keyless, offline-first design front door. `/design` routes a design intent to a mode and renders it as self-contained HTML/SVG (no CDN, no paid keys): UI screens and flows (interface), clickable prototypes (prototype), design systems, tokens, and brand identity (system, including BRAND.md), architecture/flow/ER diagrams (diagram, via plan-render's diagram-conventions), infographics and data-stories (dataviz), slide decks (deck), auditing an existing screen, site, or app for ranked findings, a paste-ready fix brief, and standing design laws (critique, with deterministic WCAG-contrast and anti-tells checkers in scripts/), and anticipating a flow's dead-ends (anticipate). Vector assets (OG cards, SVG logos, icon sets, posters) render offline too; true raster (photo, illustration, painterly cover) is an optional layer that degrades to a spec plus an editable placeholder plus enable-steps rather than hard-failing. Every mode loads design-core first: visual hierarchy, WCAG AA contrast, colorblind-safe palettes, brand-probe, browsing the live web for current inspiration instead of frozen examples, the anti-tells catalog (what makes a design read as AI-generated), precise non-marketing copy, and render/screenshot/critique verification. Brand plugins layer on top by calling /design; brand is optional, never required.

yc — local recreations of YC startup products whose core functionality can be delivered by a general-purpose agent plus focused skills and deterministic scripts. First recipe: `/yc:workweave`, a private browser-ready engineering-intelligence report from the local agents-cli index.