This page is made from the same text as slipdock help, so it always matches the CLI this server serves. Installing it is on the CLI's page.

slipdock <command> [args] [--json] [--url URL]

slipdock — read and write cards on your Slipdock boards

Start here

guide [section]
how to use these boards as a work tracker, from the server itself: epics and subcards, what to pick up next, what to write back as you go. With no section, the short guide, ending with the names of the rest; `guide <name>` one of them (`guide wiki`); `guide all` the whole guide, which is long (GET /api/guide?section=short|<name>|all)

Find anything

(semantic: matched by meaning, so the words you type needn't be the words that were written; covers cards, comments and status updates)

search <words...>
search every board you can see
--board B     only that board and its sub-boards
--kind cards|pages|files|all   cards and comments, wiki pages, wiki files, or all (default)
--limit N     how many results (default 20, max 50)
--archived    include archived cards (a card's #id or link
              as the query finds it, archived or not)
--full        print the whole matching text, not a snippet
ask <question...>
ask the assistant, which searches for itself and answers in prose, naming the cards it read
--board B     keep it to one board (id, code or name)
search-status
what is indexed, and whether anything is queued
saved [--ask | --mode search]
the searches and questions you have saved (yours alone)
save <words...> [--ask]
save a search (with --ask, a question)
unsave <words...> [--ask]
take one off the list (or `unsave --id N`)

Auth

url [<url>]
which server to talk to, saved in ~/.config/slipdock/url so it need not be in the environment (`url --remove` forgets it). $SLIPDOCK_URL still wins for a one-off
auth
sign in without a token: shows a code to approve in a browser, then saves the token it is given
--label TEXT  what the approval screen calls this client (default: this host)
--scope read|write   what to ask for (default: write)
auth <token>
save an API token directly (create one at /account/tokens)
names [full|short]
says or sets Names in trees and lists: full titles or short names, in the web app and clients
whoami
show who you are signed in as (and how many things are waiting on you)
work [--board B] [--done]
my work: what is waiting on you (waits, review and waiting flags, runner trouble, cards in progress with nobody on them), oldest first, then my cards by due date
work --dismiss <card> | --undismiss <card> | --dismissed
take an item off my own list, held on its cause (a second failed job or a new wait shows again); undo it; list what I dismissed
work --mute <board> | --unmute <board>
keep a board's tree off my own list; the board works as before for everyone
multiboard [--list L]... [--limit N] [--by board|list|grid]
the top N cards (default 5) of lists from several boards; L is a list id or board/list ("ops/To Do"). No --list: the view saved on the Multiboard page
multiboard <saved>
one of your saved multiboards (id or name), with its cards
multiboards
your saved multiboards: id, name, colour, lists
save-multiboard <name> [--list L]... [--limit N] [--by B] [--color C]
save a multiboard view by name; it goes on your home page among your boards. No --list: the page's view
set-multiboard <saved> [--name N] [--color C] [--list L]... [--limit N] [--by B]
rename, recolour or change a saved multiboard
delete-multiboard <saved>
delete a saved multiboard (the boards stay as they are)
passkeys
your passkeys: name, when added, when last used, and the fingerprint of each one's public key (to pin on a machine)
passkeys remove <id>
remove one (a lost phone) — it can't sign in after. Adding one needs the device, so is in a browser only
inbound log
your last 50 emails to this server's inbound addresses, and what came of each: what it made, or why it bounced or was ignored. Only while the server receives mail
inbound <board> [--rotate]
your address for emailing cards onto a board (it only takes mail from you, and the board's permitted senders, which it lists); --rotate makes a new one, and mail to the old one bounces from then on
--folder F                        a wiki folder's own address instead (a path, name or
                                  id): mail to it is a page in that folder
inbound me [--rotate]
your personal Quick Add address: the subject picks the board, list, priority and due date
--ack on|off                      email me back a link to each card my mail makes
ai-key [<key>]
show your stored API key (masked), or set one; `ai-key --remove` deletes it
ai
which model your AI requests go to: endpoint, key, model
ai-endpoint [<url>]
point at any OpenAI-compatible API — a local LM Studio, Ollama, llama.cpp, vLLM — instead of OpenRouter; no key needed for most. `--key K` sets one at the same time, `--remove` goes back to the server's default
ai-models
what that endpoint can run
ai-model <id>
pick one (`--embed <id>` for the search index too). AI features need a key or an endpoint
logout
forget the saved token

Admin

(needs a token made with the admin scope — Account → API tokens)

admin settings
what this server allows, and who it tells
admin build
the commit and build time now running
admin set key=value...
signup_mode=open|allowlist|approval|closed, free_card_limit=20, user_directory=shared_only, invites_create_accounts=false, trial_days=30, trial_enabled=true, board_limit=1000, item_limit=250000, storage_limit_mb=10240, and <name>_enabled=false to switch any limit off posthog_key=phc_... posthog_host=https://eu.i.posthog.com for analytics; posthog_key= turns it off [email protected]: whose AI key semantic search and scheduled automations use (an admin's); ai_system_user= clears it transcription_server_url=https://host:8765 (your own transcription server: Transcribe on a card's recording; empty: off), transcription_server_token=<key> (empty: none) block_external_images=true: pages and cards load pictures only from this server, showing others as links
admin allow <entry>
let an address or a whole domain register
admin disallow <entry>
admin users
who is here, what they use, when last seen
admin overview [--sort S]
usage at a glance: accounts, active and joined in 7/30 days, and per person signed up, last active, boards, lists, cards, pages, files, storage (S: storage|cards|boards|lists|pages|files|last_active| signed_up|email)
admin promote|demote <email>
admin rights (never the last admin)
admin disable|enable <email>
reversible; ends their sessions at once
admin limit <email> <n|none>
an item limit of their own
admin paid <email> <date|none>
paid up to a date: off the free tier and off the trial clock (e.g. 2026-12-31)
admin unlimited <email> on|off
off the free tier for good, no date needed; the server-wide ceilings still apply
admin transcription <email> on|off
let them use recording transcription and voiceprints (admins always may)
admin signups
who is waiting to be let in
admin approve|reject <email>

Read

boards [--archived|--all] [--sort S]
list boards you own or that are shared with you
(archived boards are left out unless asked for; S: manual name active newest oldest cards)
board <board>
show a board with all columns and cards
columns <board>
list columns (lists) on a board
tags <board>
list tags on a board
cards <board> [filters]
list cards on a board
--column C  --tag T  --priority P  --flag F  --search Q
--kind card|document                      (document: a card that is just its file)
--due overdue|today|week|month|has|none   (still-outstanding dates)
--deps blocked|ready|blocking|violated|free
--assignee NAME|EMAIL|me | --no-assignee
--open | --done   --archived (archived alone) | --all (archived too)
--snoozed include|only                    (snoozed cards are left out otherwise)
--stuck                                   (in their list longer than it usually takes)
--driver all|agent|human                  (who holds or last moved it; runner boards)
--origin person|sweep|findings|health|overseer|verify|release|automation|import|agent|none
                                          (who or what made it; none: made before origins)
card <id>
show one card in full (checklist, comments)
activity <board> [--limit N] [--card ID]
recent activity on a board (or one card), with who did each
dora <board> [--env E] [--days N]
the board's delivery performance from its recorded deploys: deployment frequency, lead time, change failure rate, time to restore, rework rate and idea to production, each with its DORA band and the trend (needs the board's delivery metrics on; see `deploy`)
handbook <board>|<card>
the handbook (Handbook/ wiki pages) of the board's tree: its index, decisions and rule count, or the sections a card should read before building (also in `card`)
--paths a,b       the pages whose covers: take those paths in, and the
                  board's rules that apply to them, `must` first
--paths-from -    the same, one path per line from stdin (or a file):
                  git diff --name-only main | slipdock handbook B --paths-from -
pulse <board>
the board's flow numbers: in progress, waiting, done in 7 days and today, P50/P85 time to done, moves in 24h forward and back, and each list's in/out and usual stay
flow <board> [--days 7|30|90]
the board's flow day by day: cards in backlog, ready, doing and done, completed, added and open each day, completed per week, and P50/P85 cycle time
quality <board> [--days N]
how well agent work goes (30 days unless given): cards accepted first time, rejections per card and by handbook area, job timeouts, failures, requeues and give-ups per 100 jobs, health incidents fixed and flagged, rejections by part (the ask, bar, rules, suite, Handbook line) and by rule id, disputed Handbook lines and audits
--rules           every rule broken in the window, with its page (the top 5 without it)
swimlanes <board> [view opts]
cards as a grid, grouped on two axes
table <board> [view opts] [--fields F]
cards as a table (F: comma list of
id title column priority assignee flags tags start due completed percent time checklist comments deps subcards
rollup health created updated)
views <board>
list saved swimlane views
automations <board>
list the board's automation rules
automation <board> <rule>
show one rule, spec and all
automation-help
the triggers, conditions and actions a spec may use
automation-presets
the ready-made rules `new-automation --preset` can add
callbacks <board> [--limit N]
the calls the board's rules have made, and what came back
alerts
alerts automation rules have raised for you
runners <board>
the runners taking jobs from the board's tree (owner only)
pool-grants <board>
who besides the owner takes each runner pool's jobs (owner only)
pool-grant <board> <pool> [EMAIL] [--off]
grant a writer of the board the pool, so their sessions and machines take its jobs; --off takes it back; with no EMAIL, who has the pool. Only the owner and those granted take a pool's jobs
now <board>
right now on the board's tree: each runner at work and its jobs' steps, the cards in progress with where they sit and what holds them, the queue with why each job is held, and the idle runners last
runner-stats <board> [--days 7|30|90]
how the board's runners are doing: status, outcomes, job time, queue wait, waits on people, reopened cards and the last 12 jobs
jobs <board> [--status S] [--limit N]
jobs the board's rules sent to runners, newest first (S: open, queued, claimed, running, done, failed, cancelled, timeout)
jobs --card ID
one card's jobs
job <id>
one job: status, runner, prompt and the tail of its log
job <id> --follow [--interval SECS]
a running job's live log as it arrives, one line per message, tool call or result, until the job ends
job-log <id> [--follow]
the job's live log so far (--json: one entry per line)
job <id> --keep
keep an ended job's log: written as a page Pass <card> (<date>) in the card's folder, so it never expires
templates
list board templates (sets of lists)
fields <board>
list custom fields (and their {keys} for formulas)
milestones <board>
list milestones on a board tree

Favourites

(yours alone; in the web app they are the phone's Favourites tab, two taps from anywhere — nobody else's list changes)

favourites
list what you have favourited, with the URL of each
fav card <id>
favourite a card
fav list <board> <column>
favourite a list (opens the board at that list)
fav view <board> <view>
favourite a saved view
fav board <board>
favourite a whole board
fav page <page>
favourite a wiki page (W-31, its slug or board/slug)
unfav <same args>
stop favouriting it (or `fav ... --off`)
hotkeys
your board hotkeys: Ctrl+Shift+a digit in the web app
hotkey <board> <0-9|none>
give a board a digit (it leaves any other board), or none
header
your header links: boards, and your wiki, pinned left of quick add in the web app, and the icons they can wear
header add board <ref> --icon NAME | header
add wiki --icon NAME pin one (again: change its icon); up to 8
header rm <id>
unpin one
header move <id> left|right
move one a place along
card-views [--elements]
your card views: which elements of a card you see (--elements: every element a view can set, and its default)
card-view show <view>
one card view (its id or name): what it shows and hides
card-view new <name> [--show a,b] [--hide c,d]
save a named card view
card-view edit <view> [--name N] [--show ..] [--hide ..] [--inherit ..] [--reset]
rename it or change its elements (--inherit: stop stating)
card-view rm <view>
delete one; the levels that applied it keep their own
card-view level [--board B] [--list L]
what you state at a level: global with no --board, a board's with --board, a list's with both
card-view set [--board B] [--list L] [--apply VIEW|none] [--show ..] [--hide ..] [--inherit ..] [--reset] [--show-all on|off]
change a level (--show-all: a board's, shows every element)
card-view clear [--board B] [--list L]
clear a level, so it inherits everything
card-view applied [--board B] [--list L] [--view SAVEDVIEW]
each element shown or hidden on a card there, and why (default, global, board, list, saved view, show all, board setting). Agents' output never follows card views

Wiki

(Markdown pages on a board: how it works, what was decided and why. A page answers to its code — W-31 — its slug, or board/slug.)

page ls <board> [--q TEXT] [--archived|--all] [--template] [--draft] [--folder F | --no-folder] [--recent]
--recent: the most recently edited first, the
newest 100 (the wiki tree's Recent view)
page tree <board>
the page tree, nesting shown by indent
page read <page>
print the Markdown source
page tags <board>
the tags its notes give themselves (front matter tags and inline #tags), with counts. page ls <board> --note-tag T lists the notes tagged T or anything under it (T/sub)
page props <page> [--body TEXT | --file F | --clear] [--message M]
the front matter its file came with, kept exactly as written; with --body/--file, replace it (YAML only, no --- lines); --message M is why, recorded in the page's history
page render <page> [--format markdown|html|text]
the same with every reference resolved: links followed, #412 filled in with what the card says now, [[!toc]] expanded
note <text...>
save a quick note in your wiki; the server names and files it, and says where (--body - reads stdin)
page new <board> <title...>
write a page
--body TEXT | --file F | --body -   (- reads the body from stdin)
              a --- front matter block at its top is kept as the
              page's front matter (see page props), not as text
--parent P    put it under another page
--folder F    file it in a folder — a name or a path, made if it is new
--card N      a page for that card: in its folder, pinned to it
--summary S   one line, shown in listings
--message M   why, recorded in the page's history
--draft       only writers can see it
page edit <page> [--title T] [--summary S] [--body TEXT|--file F|--body -]
a --- front matter block at the top of the new body replaces the page's front matter; without one it stays
--message M   why (write one every time)
--base-hash H the hash you read (see `page read --json`); a save that
              would land on someone else's is refused, not applied
--draft | --publish
the card facets, so a doc on the board reads like one:
--priority P  --flag F (repeatable) / --flag F --off
--tag T (repeatable) / --tag T --off   the board's tags, by name
--set-tag T (repeatable) replaces them all  --no-tags clears them
                            (not the note's own #tags: those are its text)
--start DATE | --no-start   --due DATE | --no-due
--percent N | --no-percent  --color C | --no-color
--assignee EMAIL | --no-assignee   --done | --undone
--folder F | --no-folder
--icon I | --no-icon        what it wears in the wiki, tinted by --color
                            (icons: see `folder new`)
page file <page> --folder F | --no-folder
file it in a folder, or take it out of one. Where a page is *kept*; `page mv` is what it is *part of*
page file <page> --also F | --not-in F [--board B]
file it in one more folder as well as its home (one page, several places), or take it out of one. F is a folder on its board, on --board B, or a path in your wiki ("/Projects/Notes")
page mv <page> [--parent P | --root] [--position N|top|bottom]
page mv <page> --board B [--folder F] [--dry-run]
to another board of yours: it keeps its code, history and comments; tags, fields and pins go where that board has a match (--dry-run says which won't)
page rm <page> [--purge]
archive it (--purge deletes, owner only)
page restore <page>
page history <page> [--limit N]
every save, who made it and why
page diff <page> [--rev N] [--against M]
what a version changed (default: the latest), or with --against how it differs from version M
page revert <page> --rev N [--message M]
page ai <page> <tool>
an AI tool over the page, on your AI key: summarise, key_points, actions, titles or improve. It only answers
page sections <page>
the heading paths a section may be addressed by
page section <page> <path>
print one section
page section <page> <path> --append TEXT | --body TEXT | --file F [--message M]
add to, or replace, one section. Appending cannot conflict and needs no hash — the write to prefer. An append lands at the end of the section's own text, before its first subsection; text with a heading of its own goes after the subsections
--append - and --body - read the text from stdin
page append <page> --body TEXT|--file F [--message M]
add to the end of the page
page encrypt <page> [--section S] [--hint H] [--purge-history]
encrypt the page, or one section, in Meld Encrypt's format (Obsidian opens it). Done here: the passphrase, asked for twice, and the text never reach the server. Earlier revisions still holding the text are counted;
--purge-history deletes them (the board's owner only)
page decrypt <page> [--section S] [--in-place]
print the page, or a section, with its encrypted blocks opened; --in-place removes the encryption and saves the plain text. Both take --passphrase-file F or $SLIPDOCK_MELD_PASSPHRASE where nobody can type it
page links <page>
what it points at, what points at it, what it wanted
page pin <page> --card N | --page P [--off]
"this page is *the* spec for that"
page wanted <board>
pages linked to but never written — the wiki's backlog
page resolve <board> <title...>
is there a page for this, and what do I write?
page query-help
the grammar a ```slipdock block is written in
page query <board> --body -
try a block without writing it anywhere
page place <page> <column> [--before REF]
put the page in one of its board's lists, so it sits beside the work and can be dragged like a card (REF: a card's number, or page-7)
page unplace <page>
take it off the board; it stays in the wiki
page publish <page> [--off]
read-only at a public link; its live queries are answered once, when you publish (publish again to refresh them). --off withdraws the link
page share <page> [EMAIL|GROUP] [--read|--comment|--write] [--off]
share it with a person (an email; a stranger is invited) or a group of yours, read only (default),
--comment (read, comment, report a status, vote;
no edits) or --write; --off takes it back; nobody
named lists who has it. Only its board's owner
can share, or its writers where the owner set
--editors-may-share
shared
what other people have shared with you, by owner; `page read` and `page edit` take the codes it lists
export [<board>...] [--out FILE]
whole board trees as one JSON document: lists, cards, subcards, tags, checklists, comments, custom fields, dependencies and the wiki. No board named takes every one you own; --archived brings in what is put away. Without --out it goes to stdout
import <file.json> [--from SRC]
build the trees in a document. Always new boards — it never merges into what is already here. A Trello board's JSON export works too, recognised by its shape; --from trello says so outright
page export <board> --dir D
write the wiki out as .md files with front matter
page import <board> --dir D [--overwrite]
read a folder of Markdown in; folders become parents, and a title already on the board is skipped
page switch <board> <letters...> [--limit N] [--all]
the quick switcher: notes whose title, alias or path the letters run through in order, across your wiki
page card <card-id>
the pages that talk about a card, pinned first
page from <board> <template> --title T [--set k=v]... [--card N] [--folder F]
a page from a template page, {{placeholders}} filled
writeup <card-id> [--template T] [--title T] [--folder F]
start a page for a card, pinned to it
page make-card <page> --body TEXT|--file F [--column C]
turn a passage of a page into a card, linked both ways

Folders

(where pages are kept, nested to any depth. A folder answers to its id, its slug, its name, or a path of names — "Design/Decisions". Deleting one never deletes writing.)

wiki
every board's wiki at once: boards, then folders
wiki files <board> [--folder F]
the wiki's files that are not pages, by path (a Tool's board files are in its Tool folder)
wiki get <board> <path> [--out F|-] [--force]
save one by its path ("Tool/cv.docx") under its own name here, as F, or to stdout (--out -)
folder ls <board> [--short-names]
the board's filing, pages and all; card folders by their short names (pages have none)
folder open <board> [<folder>] [--page P] [--all]
one level of the tree, as the web's tree loads it: folders, pages and files with how much is under each, never a body. No folder: the top of the wiki
folder new <board> <name...> [--parent F] [--icon I] [--color C]
a name with slashes makes the whole path.
--icon and --color: what it wears on the wiki's
main page and in its tree. Icons: star heart
bookmark flag bolt fire light-bulb sparkles
rocket-launch beaker book-open academic-cap
briefcase calendar chat-bubble-left-right
check-circle clipboard-document-list code-bracket
cog-6-tooth cube currency-dollar document-text
exclamation-triangle globe-alt home inbox key
lock-closed map megaphone musical-note photo
puzzle-piece shield-check tag trophy user-group
wrench-screwdriver archive-box folder. Colours:
slate red orange amber lime emerald teal sky
indigo violet fuchsia rose
folder mv <board> <folder> [--name N] [--parent F | --root] [--position N] [--sort board|manual|name|modified|created]
how the tree orders the pages in it [--icon I | --no-icon] [--color C | --no-color]
folder mv <board> <folder> --board B [--parent F] [--contents] [--dry-run]
to another board you can write to, with its subfolders, every page in them and their files; pages keep codes and history. --contents moves only what is in it (the folder itself goes).
--dry-run: what would move and what can't
folder show <board> <folder>
one folder: its path, and where else it is filed
folder share <board> <folder> [EMAIL|GROUP] [--read|--comment|--write] [--off]
share a folder and everything in it, subfolders and all, as `page share` does a page
folder file <board> <folder> --also F | --not-in F [--board B]
file it in one more folder as well as its home (one folder and all in it, several places), or take it out of one; both repeat. F is a folder on its board, on --board B, an id, or a path in your wiki ("/Projects/Notes"). Never inside itself, by any route
folder rm <board> <folder> [--purge]
delete the folder only: its subfolders move up and its pages go back to the root. --purge deletes the pages in it as well, history and all (owner only)
folder organise <board> <folder> --by
date|ai|tag|flatten [--dry-run] sort what is filed in the folder. date: into <parent>/2026-10 (--parent F, default the folder;
--root for the top; --per month|year|year_month|day;
dated by created:/date: front matter, else when
added — --added for always when added). ai: a cheap
model suggests homes under existing top-level
folders. tag: a subfolder per first tag. flatten:
everything in its subfolders back up into it.
Missing folders are made. --dry-run: the plan only

Your wiki

(one tree: your Knowledge Base first, then a folder for every board you own, a sub-board in its epic's folder; archived boards are left out)

wiki show
your wiki: its Knowledge Base, its boards, page count and the folders it is synced to
wiki set [--shortcut K] [--hotkey 0-9|none] [--recordings-folder PATH]
the folder on your Google Drive its meeting recordings are in ("" clears it); a page whose front matter says recording: gdrive:<path> plays it beside its transcript
drive status
your Google Drive connection, and your wiki's recordings folder
wiki locate <path>
which board a path in your wiki lands in, and the rest
wiki resolve <link...>
the page a [[link]] finds anywhere in your wiki (Note, or Folder/Note; the shortest path wins)
wiki wanted
pages linked to but never written, every board at once
wiki tree [--short-names]
every folder and file by name
wiki changes [--since N] [--limit N] [--short-names]
what changed (pages, folders, attachments) after cursor N, each once and as it is now; without --since, the cursor to start from. What sync polls
wiki import <dir> [--dry-run] [--all]
bring an existing Obsidian vault in, once: each note a page and each other file a file at its path in your wiki, in the board whose folder holds it, bytes as they are (front matter, Excalidraw, Meld ciphertext). What the server has at a path already is left alone. --dry-run says what would be created or skipped, and which links, embeds and plugin blocks won't resolve. Afterwards, `sync init` on the same folder adopts the files instead of duplicating them

Sync

(your wiki mirrored both ways to a local folder that stays a valid Obsidian vault. The server is the source of truth; the folder is a working copy, and anything that writes a file into it writes into your wiki)

sync init <dir>
bind a folder to your wiki, then run once. Files already there that match your wiki are adopted, not duplicated
sync [<dir>]
one pass, both ways (default: the folder you are in). A .md file is a page; images, PDFs, .excalidraw and other files are kept at the same path (250 MB each), so ![[image.png]] works on both sides. A rename or move is the same page; a delete archives it. Changed on both sides: the server's version keeps the path and yours is saved beside it as "Name (conflict DATE host).md", and synced too. Dot folders (.obsidian, .trash) and editors' temp files are left alone, and so is anything named in .slipdockignore (gitignore-style: *.pdf, Private/)
--watch       keep running: a pass once the folder has been still for 2 s, and
              whenever the server's change feed has news
--interval S  how often --watch asks the server (default 10)
sync from-server [<dir>]
one pass that only brings changes down: nothing is sent, archived or moved on the server
sync to-server [<dir>]
one pass that only sends changes up: nothing in the folder is written, moved or removed. Either way what it skips is listed as held (·) and stays waiting for the next pass; a conflict waits for a pass both ways.
--watch and --json work as for sync
sync status [<dir>]
the last sync, what is waiting on each side, conflicts left to resolve, and a warning if Obsidian Sync, Dropbox, iCloud, OneDrive or Syncthing is syncing the same folder (two sync tools on one folder fight)
sync service install|uninstall|print [<dir>]
run sync --watch in the background: a systemd user unit, a launchd agent or a Windows logon task. print shows what install would do

Skills

(the agent instructions this server ships, versioned with its API)

skills
list them, with a version each
skills install [--dir D]
write them to ~/.claude/skills (or D)
skills check
say whether the local copies are behind
skills chatgpt [--dir D]
save ChatGPT's versions, one zip per skill, here (or D)
skills board <board> [<name>]
the registry skills enabled on a board: what its agents get. With a name, that one's pinned text (the plan skill uses it for a Playbook stage naming it); --json for all

Registry

(skills fetched from outside Slipdock, such as a GitHub repo of SKILL.md files)

registry
your skill sources and the seeds, with a count each
registry add <url> [--seed]
fetch a source: a GitHub repo, a folder or file in one, or a SKILL.md at an https URL; --seed adds it for everyone on the server (admins only)
registry source <id>
one source: its skills, and what the fetch left out
registry refresh <id>
fetch it again: which skills were added, changed, removed
registry rm <id>
remove a source and its skills
registry entry <id>
one skill in full, its content_hash, where it is enabled and which Playbook stages name it
registry enable <entry> --board B --hash H
enable it on B, pinned to the text you read (H is its content_hash from registry entry); a writer only
registry repin <name> --board B --hash H
re-pin a skill changed upstream to its new text
registry disable <name> --board B
take a skill off B
registry stages
the Playbook stages naming a skill, and what each gets

Tools

(packages of docs, files, a board and skills that people on this server share)

tools
the Tools you can see: yours, shared with you, listed
tools show <name> [--version V]
what one holds: its board, skills, files and versions
tools publish <dir>
pack the folder (tool.json, README.md, board.json, skills/, files/) and publish it as a new version
tools install <name> [--version V] [--dir D]
put its skills, and the files that go beside them, in ~/.claude/skills (or D)
tools check [<name>...]
say whether the installed Tool skills are behind
tools request-listing <name> [--version V]
ask an admin to list a version for everyone here
tools install-board <name> [--version V] [--name N]
have the server build the Tool's board for you (again: answers with the board you already have)
tools install-board handbook --board B
put the built-in handbook (Handbook/ pages that loop passes read and update) on B's root board
tools install-board sweep --board B
put the built-in code sweep (a Sweeps rotation page, a Triage list nothing feeds from, and a weekly Sweep the code card) on B's root board
tools file <name> <path> [--version V] [--out F]
one file of the package by its path (skills/<skill>/SKILL.md, files/build.py) to stdout or F; the latest version unless --version
tools download <name> [--version V] [--out F|-] [--force]
the whole package, every file at its path, as <name>-<version>.tar.gz (or F, or - for stdout): unpack it, change it, publish it again

Write

add <board> <title> [opts]
create a card
--column C (default: first column)  --desc TEXT  --priority P
--short-name T              up to 40 characters for tight spaces (made for you if left out)
--assignee EMAIL|me (repeatable: everybody on it, the first is the lead)
--flag F (repeatable)  --tag T (repeatable)  --start YYYY-MM-DD  --due YYYY-MM-DD  --color C
--percent N (0-100)  --border C, --border-top/-right/-bottom/-left C   (see edit)
--spent T  --estimate T  --unit minutes|hours|days|weeks|months   (time tracking; see edit)
--bar TEXT  --paths "G1,G2"  its bar and the globs its work touches (see edit)
--profile P                 what kind of change it is (see edit)
--caused-by N  --missed-by L  file it as an incident (see edit)
--origin sweep|findings     inside a runner job, the generator filing it (the server
                            records every other origin itself)
--archived                  archive it as soon as it is made (a record of finished work)
--desc - and --bar - read the text from stdin (a heredoc keeps its lines; one per command:
                            a second - is refused, on any command)
edit <id> [opts]
change fields on a card
--title T  --desc TEXT  --priority P  --start DATE | --no-start  --due DATE | --no-due
--color C | --no-color  --column C
--short-name T               a name for tight spaces; "" hands it back to be made
--border C | --no-border     every edge of the card's front in palette colour C;
--border-top C  --border-right C  --border-bottom C  --border-left C
                             one edge (after --border, so the edge wins); C none
                             takes that edge's colour off
--assignee EMAIL|me (repeatable; replaces who is on it) | --no-assignee
--add-assignee EMAIL|me  --remove-assignee EMAIL|me   (repeatable; others stay)
--percent N | --no-percent   (% complete, 0-100)
--bar TEXT                   what done means for the card; on a board with
                             --bar-required it locks when work starts
                             (--desc - or --bar - reads it from stdin)
--paths "G1,G2"              the files its work touches, as globs (lib/x/**), split
                             on commas or newlines; "" clears. They scope the
                             handbook rules the card carries and its inferred profile
--profile P | --no-profile   what kind of change it is: security, schema, feature,
                             fix, docs or spike. On a board with --profiles on, an
                             agent claiming or starting a card with none gets one
                             inferred; its human tier says whether an agent's
                             acceptance merges or waits for a person
--spent T | --no-spent  --estimate T | --no-estimate   time spent and the estimate.
                             A bare number is in the card's unit; or say 90m, 1.5h,
                             2d, 1w, 1mo, "1h 30m" (a day is 8h, a week 5d, a month 4w)
--unit minutes|hours|days|weeks|months   how the card shows both (default hours)
--log T                      add T to the time spent (--log=-30m takes it off)
--caused-by N | --no-caused-by   this card is an incident: N (or #N) is the card
                             whose shipping caused it, on any board you can read
--missed-by L | --no-missed-by   the check that should have caught it: bar, rules,
                             ci, verify, audit or none. With --caused-by it records a
                             process finding (source incident) on the causing card;
                             `slipdock findings B --source incident` lists them
timer <id> start|stop
run a card's timer; stopping adds what it ran to the time spent
log <id> <time>
add time spent by hand (same as edit --log)
repeat <id> "every mon" [--at 07:00] [--lead 2] [--ends DATE | --count N] [--on-missed bump|skip|stack] [--column C] [--tz Europe/London]
make a card recurring, or change how: the next one is a copy of it, made in --column, else the board's Scheduled list, else its ready list. Rules: day, weekday, mon, mon,thu, 2w mon, month 1, month last fri, month first mon, year, 3d after (after the last is done), or FREQ=WEEKLY;BYDAY=MO
repeat <id>
how it repeats, and the next three dates
repeat <id> --skip | --pause | --resume | --off
let the next one go / hold it / carry on / stop it
recurring <board>
every card on the board that repeats, soonest first
snooze <id>... <when> [--note T] [--notify]
hide cards until a date (2026-11-02, tomorrow, mon, next week, in 3 days; midnight where you are). They wake at the top of their list, or sooner when someone else comments or assigns them. --notify alerts then
wake <id>...
bring snoozed cards back now
overseer <board> [--on | --off] [--pool P] [--min-minutes N] [--max-minutes N] [--idle-minutes N] [--email | --no-email] [--digest-at HH:MM]
the overseer: an eye on outcomes. Shows whether it is on, its next pass, the last digest and the open conditions (looping, waiting while idle, slow, idle capacity, no way forward), each with why and what to do. --on turns it on; passes come every --min-minutes (10) while cards are active, up to --max-minutes (120) when nothing is in flight, on a runner whose config has job_overseer.
--digest-at: when the morning digest of Housekeeping's
work is written (07:00, your time zone)
garden <board> [--run] [--check K]
tidy-up suggestions: epics done but open, cards stuck in progress, overdue, duplicates, orphaned pages, mistyped [[links]]. --run looks the board over first
garden apply <id>... [--keep CARD] [--choice NAME]
apply suggestions you approve (--keep: the duplicate that stays; --choice: one of its alternatives)
garden dismiss|undo <id>...
dismiss (it stays dismissed) or undo an applied one. A proposal (a handbook edit) is not decided here: a person decides it on the board's Tidy-up page (/boards/<id>/tidy), and the CLI is refused with its link
garden settings <board> [<check> key=value...]
show the checks, or change one (enabled=false, days=30)
garden propose <board> <file.json | ->
file a proposal for a person to apply on the Tidy-up page, such as a handbook rule added or reworded: {"explanation": "…", "steps": [{"op": "edit_section", "page": "W-12", "section": "Page/Rules", "body": "…"}]} Proposals on one section apply one after the other, each as its own lines; the listing says which share one
health <board> [--run]
work the health monitor found stuck on the board tree: open, flagged for a person (the stuck flag), and lately fixed or cleared. --run looks it over now
health settings <board> [<detector> key=value...]
show the detectors, or change one (enabled=false, max_attempts=3, or a threshold)
findings <board> [--status S] [--kind K] [--source S] [--card ID] [--days N] [--scope board|runner|all]
what cards taught (Findings: blocks) and what the system saw go wrong, on the tree's root board; open by default (S: open|waiting|promoted|dismissed|merged|all). One row per lesson, with the other cards it was said on ("also #12"). waiting: open, but named by a proposal that waits on a person ("[waiting on proposal #7]"); left out of open, as triage has nothing to decide on it. --scope runner: the tooling (runner) items kept with a runner. First, what waits on you: the proposals drafted from findings ("2 proposals await you"), each by id, for a person to decide on the board's Tidy-up page, which the listing links (a proposal is a person's call)
finding <id> dismiss|promote|reopen [--note TEXT]
triage one (promote: say what it became, W-1950 §Tests;
--note - reads it from stdin)
finding <id> merge --into ID
fold a repeat into another finding, adding its count
ledger <board> [--since S]
what shipped on the board tree since 07:00 yesterday (S: days, a date or an ISO time): each card completed, accepted, merged or deployed, with who accepted it, its evidence, the should rules it missed and its lead time
copy <id> [--board B] [--column C] [--title T] [--top|--bottom]
a copy of the card as it is now: checklist unticked, subcards reopened; no comments, dates or attachments. Lands straight after the original unless told otherwise
move <id> <column> [--top|--bottom|--index N]
move <id> <column> --board B
move the card to a list on another board, with its subcards; tags travel by name, custom fields only where that board has the same one
done <id>... | undone <id>...
mark complete / incomplete
[--evidence TEXT] [--evidence-commit SHA] [--branch B] [--tests F,F]
[--suite passed|failed[:PASSED[:FAILED]]] [--pr URL] [--no-code WHY]
                                what you checked, the commit and branch, the test
                                files added or changed, the suite's result
                                (--suite passed:38:0) and the pull request the
                                work is in (--pr, on a board shipping by pull
                                request, with --evidence-commit its head, every
                                time; --no-code WHY, or - for stdin, for a card that
                                changes no code), when completing
                                (--evidence - reads it from stdin); a
                                board with --evidence-required asks agents for it. On
                                a board with --verify-work an agent's done submits it
[--diff-base REF] [--changed-lines N] [--changed-files F,F]
                                the change itself, on a board with profiles on:
                                --diff-base origin/main counts its changed lines
                                and files from git (REF...the evidence commit,
                                else HEAD); a bigger or stricter change than the
                                card's profile raises it, never lowers it
verify <id> accept|reject|merged [--reason TEXT] [--evidence-commit SHA]
decide a card waiting for verification: accept completes it (on a pull request board, queues the merge), reject needs the reason; not a card you submitted (--evidence-commit: what you checked at;
                                --reason - reads the reason from stdin).
                                merged: a person merged a merging card's PR by hand;
                                agree / disagree: an audit job's say on an accepted
                                card (a comment; disagree alerts the board's owner
                                and files a rework card, or comments on the open one)
--check PART=RESULT[:note]      the verdict in parts, repeated: ask=ok|misses,
                                bar:2=ok|fail, suite=412:0, rule:UX-4=ok|broken|n/a,
                                handbook_line=ok|disputed, evidence=ok|disputed. A
                                reject names a failing part; an accept can't carry a
                                broken must rule. The Handbook line and the
                                evidence's format are paperwork: kept as a finding,
                                and when they are all that fails, it accepts.
                                A rule broken in several places: one
                                rule:UX-4=broken:lib/x.ex:42 per instance, every
                                one found, all in this reject (listed under the rule).
                                rule:UX-4=pre-existing:lib/x.ex:42 is a rule broken
                                only in lines the diff didn't change: never a
                                rejection, kept as a finding.
                                defect:important|nit|pre-existing=lib/x.ex:42[:why]
                                is a defect review's finding (a schema or security
                                card): only important fails.
                                mutant:killed|survived|pre-existing=lib/x.ex:42:<mutation>[:note]
                                is a changed line the mutation review broke (a
                                schema or security card): survived fails,
                                pre-existing (unchanged lines) is kept as a finding;
                                mutants=n/a:<why> when nothing is worth mutating
--checks-file F                 the same, one per line (or a JSON map of parts)
accept <id> [--reason TEXT] | reject <id> --reason TEXT
the same as verify <id> accept / reject
flag <id> <flag>... [--off]
add (or remove) flags
tag <id> <tag>... [--off]
add (or remove) tags
check <id> <text>
add a checklist item
tick <item-id>
toggle a checklist item done/undone
move-check <item-id> [--before <item-id>]
reorder a checklist: put the item before another of the same card or page, or last without --before
comment <id> <text>
add a comment (Markdown). For more than a line,
--body - with a heredoc keeps the line breaks
(or --body TEXT, --file F)
(check, comment, status, vote, weblink, unweblink and attach take
a wiki page too: a page code like W-31 instead of a number)
link <id> <kind> <card-id>...
link cards across boards (kind: relates contributes duplicates)
unlink <id> <link-id>...
remove links (ids shown by `card`)
weblink <id> <url> [--label TEXT]
link a card to a web page, drive or file (datestamped)
unweblink <id> <url-id>...
remove web links (ids shown by `card`)
attach <id> <file>... [--name N] [--hide-on-card] [--replace]
upload files to a card or page; prints the Markdown that embeds each (an image shows inline, anything else links). A card's first image is the thumbnail on its front unless
--hide-on-card keeps it off. --replace deletes older files
of the same name once the new one is in
transcribe <id> <attachment-id> [--wait]
send a card's recording to the transcription server;
--wait prints the transcript once it is done
attachment-text <attachment-id>
print the words read from a PDF or image (OCR)
read-text <id> <attachment-id>
read a card's PDF or image for text again
card-front <id> <attachment-id>... [--off]
let an image be the card's thumbnail (--off: keep it off)
attachments <id>
list a card's or page's files
download <attachment-id> [--out F] [--force]
save a file's bytes, under its own name here, or as F (--out - writes it to stdout)
detach <id> <attachment-id>...
delete attached files
blocked-by <id> <card-id>... [--off]
mark <id> as waiting on other cards, on any board you can read (or remove)
blocks <id> <card-id>... [--off]
mark <id> as holding up other cards; you need write on theirs (or remove)
archive <id>... | restore <id>...
archive / restore cards
delete <id>...
permanently delete (prefer archive)
new-board <name> [--code C] [--shortcut K] [--desc TEXT|-] [--color C] [--template T] [--list "Name[:wip[:color]]"]... [--save-template NAME]
--list (repeatable) sets the board's own lists instead
of a template's; --save-template keeps them as one too
welcome [--force]
build the "Getting Started" board: a tour of the whole app, cards, subcards, automation and wiki pages included (the one a first sign-in makes by itself)
set-board <board> [--name N] [--code C] [--shortcut K] [--desc TEXT|-] [--color C] [--no-add-card] [--no-add-page] [--no-add-document] [--sprints | --no-sprints] [--simple | --no-simple] [--page-card-features | --no-page-card-features] [--show-pulse | --no-show-pulse] [--close-on-complete | --no-close-on-complete] [--editors-may-share | --no-editors-may-share] [--automation-wip | --no-automation-wip] [--agentic-building on|off] [--job-log-hours N] [--failure-log-hours N] [--delivery-metrics | --no-delivery-metrics] [--incident-tag T] [--hotfix-hours N] [--not-shipped-minutes N] [--card-ref-pattern RE] [--default-view V] [--handoff-label L] [--handoff-prompt TEXT | --handoff-prompt-file PATH] [--inbound-senders LIST] [--sensitive-paths LIST] [--wiki-sort manual|name|modified|created] [--bar-required | --no-bar-required] [--evidence-required | --no-evidence-required] [--verify-work | --no-verify-work] [--verify-pool POOL] [--verify-rejection-limit N] [--verify-audit N] [--findings-propose-at N] [--wait-default-after TIME|off] [--sensitivity low|medium|high] [--ship-via push|pull-request] [--release-mode on-merge|batched] [--release-age-cap HOURS|off] [--release-command CMD|default] [--route KIND=EMAIL[,EMAIL]]... [--no-route KIND]... [--profiles on|off] [--profile-tier PROFILE=TIER]...
rename a board, change its code, shortcut key or colour, say what the foot of each list offers, make it a sprint board (every card a sprint), or a simple one (a plain to-do list: % complete, start dates, health, time, votes, dependencies, Timeline and Prioritise hidden — not deleted); --no-page-card-features hides status, checklist, links, fields, votes and comments on every page of the board's wiki (not deleted);
--wiki-sort orders the top of the wiki's tree and the
folders that follow it, and needs only write access;
--show-pulse puts the board's pulse over its lists;
--close-on-complete makes an open card's Complete
icon close the card and return to the board;
--editors-may-share lets people who can edit the
board share its cards, pages and folders (off: only
the owner; set on the top board);
--automation-wip makes the first in-progress list's
WIP limit hold runner jobs and list sends;
--agentic-building on puts an Agentic Building item
on the board menu in the web app, opening the page
that holds the agent settings; off hides it and
changes no setting (a warning names any still set)
--job-log-hours (24) and --failure-log-hours (168):
how long an ended job's live log stays, and a
failed, stuck or rejected one's, unless kept;
--delivery-metrics lets the board record deploys
and shows its DORA numbers (see `deploy`, `dora`);
--incident-tag names the tag on incident cards
(incident); --hotfix-hours how soon a fix naming one
makes the deploy before it a failed change (24);
--not-shipped-minutes how long a merged card may
go with no succeeded deploy naming it before the
board raises an alert and `card` says Not shipped
(20; 0 never), overseer on or off; on a board with
batched releases they count from the card's
release, not its merge;
--card-ref-pattern the regex finding card ids in
commit messages, id in its first group (#(\d+))
--default-view picks what opening the board shows
in the web app: board, swimlanes, table, timeline,
calendar, outline, narrative, prioritise or wiki;
--handoff-label renames "Left off" where people read
a card's handoff, --handoff-prompt(-file) is what the
AI is told when it drafts one ("" for the defaults);
--inbound-senders "[email protected],[email protected]"
is every address besides your own that may mail the
board's card addresses (replaces the list; "" clears)
--sensitive-paths ".github/workflows/**,Makefile"
is the globs a person approves before a pull request
that changes them merges ("default" the defaults,
"" none)
--bar-required: agents write each card's bar (what
done means) before work starts, and it locks then;
--evidence-required: agents say what they checked
(done --evidence, --evidence-commit) to complete one;
--verify-work: an agent's completion waits for a
different agent or a person to accept it (verify);
--verify-pool sends each such card to that runner
pool as a verify job ("" sends none);
--verify-rejection-limit N: the rejection after N
opens a wait on the board's owner to rework the
card or accept it as is (default 2; 0 never);
--verify-audit N: about 1 in N cards an agent
accepted is audited by another runner in the
verify pool (0, the default, none);
--findings-propose-at N: a finding seen N times
gets a handbook rule drafted as a Tidy-up
proposal for a person (default 3; 0 never)
--wait-default-after 4h: an approval wait (kind
other, with choices and a --default) unanswered
that long goes ahead with its default, and the
person asked is told (90m, 4h, 2d; off, the
default, never; never other kinds)
--sensitivity low|medium|high: how carefully
agents proceed on the tree (root board only).
low: they decide implementation choices
themselves and no card is held by its
profile; medium (default) as before; high:
they ask before material choices, feature
cards are held before merging, and approvals
never go ahead by their default
--ship-via pull-request: agents open a pull request,
never push the default branch, and accepting the
card has a runner merge it (needs --verify-work)
--release-mode batched: a merge doesn't deploy; the
card shows merged, awaiting release, until a
release ships it (on-merge, the default, deploys
each merge). Set on the tree's root board
--release-age-cap HOURS: on a batched board,
release once the oldest waiting merge has waited
that long (off, the default, never)
--release-command CMD: the one line a runner's
release job runs (default: gh workflow run
release.yml --ref {default_branch}, the runner
putting the repository's default branch in;
any other command runs only on a machine whose
local.json lists it under release_commands)
--route KIND=EMAIL[,EMAIL]: who a wait asking that
kind of question (product, ux, security, release,
other) goes to: the first is who it waits on, the
rest are told; each must be on the board.
--no-route KIND takes the route off: waits go to the
board's owner again
--profiles on: an agent claiming or starting a card
with no profile gives it one, inferred from its paths
and tags (security, schema, spike, fix, docs, else
feature)
--profile-tier PROFILE=TIER: what an agent's acceptance
of that profile does on a pull-request board (root
board only): none or ledger merge it, before_merge
waits for a person to merge it or send it back;
default puts it back (docs/fix/spike none, feature
ledger, schema/security before_merge)
sprint <board> [--name N] [--start DATE] [--days N] [--goal TEXT|-]
start the next sprint on a sprint board: a dated card ("Sprint 4", following on from the last, 14 days unless told) with its own board of subcards (--goal - reads the goal from stdin)
sprint-add <sprint-id> <card-id>...
move cards from any board into a sprint, with their subcards; ones that can't go in are listed, not fatal
sprint-sources <board> [<source>[:list,list...]]... [--clear]
the boards (and lists on them) a sprint board's sprints are planned from; with no sources, show them. A source without lists shows every open list on it
sprint-plan <sprint-id> [--sort position|score|priority|estimate]
the planning view: every source list's open cards with priority, scores, votes and estimate (Σ: added up from its subcards), and what the sprint holds already
burndown <sprint-id>
a sprint's work left at the end of each day, against the ideal straight line to zero
velocity <board>
cards committed and completed in each sprint on a sprint board, and the average of the finished ones
archive-board <board>
put a whole board away, keeping every card on it
restore-board <board>
bring an archived board back
order-boards <board>...
set the order you list boards in (yours alone; boards left out fall to the end, oldest first)
subboard <card-id> --template T
give a card its own board of subcards
subboard <card-id> --off
remove a card's subcards
new-template <name> [--desc TEXT|-] --list "Name[:wip[:color]]"...
delete-template <template>
new-column <board> <name> [--wip N] [--color C] [--category C]
set-column <board> <column> [--name N] [--wip N] [--color C] [--category C]
change a list; category is todo, doing, done, dropped, triage (for a person), scheduled (where recurring agent work lands, worked by feed rules, never the ready list), housekeeping (generated fixes, worked by runners after the ready list and Scheduled), or "" for none (both) --sort position|created|updated|start_date| due_date|priority [--descending] and --group none| flag|tag|start_date|due_date: how the app draws it set-column --no-show-age: its cards leave off how long they have been in it (--show-age: back on) set-column --no-show-images: its cards leave their image off the front (--show-images: on)
new-tag <board> <name> [--color C]
set <id> <key>=<value>...
set custom fields on a card ("" clears; choice by label or key, several comma-separated where the field allows several; a person field takes members' emails or "me", comma-separated)
vote <id> <n>
put n of your votes on a card or page (0 removes them)
status <id> <on_track|at_risk|off_track> [note...]
report a card's or page's health (the note as words is one line; for a note of several lines, --body - with a heredoc keeps the line breaks, or --body TEXT, --file F)
handoff <id>
where the card was left: its handoff and the history
handoff <id> --next "the one next step" [--body TEXT | --file F | --body -]
leave a handoff for whoever picks the card up next (write one whenever you stop with it unfinished)
handoff <id> --clear
clear it (the history keeps that it was cleared)
handoff <id> --delete
delete the current one outright, so the one before it is current again (its author, or anyone who can edit)
timeline <id>
the lists a card sat in, its waits and its jobs: when, for how long and who moved it
wait <id> "what you need" [--on EMAIL] [--choice X]... [--default N] [--job ID] [--kind K]
wait on a person: flags the card waiting and asks on it; the job is $SLIPDOCK_JOB_ID unless --job names one. --kind is what kind of question it is (product, ux, security, release, other; other by default): it goes to the person the board routes that kind to, else the owner (on anyone without --on or a kind).
--default N names the choice you propose: the
one-click answer. "-" reads the question from
stdin: set out each option and recommend one
wait <id> ["intro"] --question Q --question Q ...
ask several questions at once: numbered, each answered on its own (use this, not one block)
wait <id> --withdraw [--reason WHY]
withdraw the card's open wait; an agent withdrawing one it didn't open (a moot wait) gives the reason, posted on the card (--reason - reads it from stdin)
answer <id> ["text"] [--choice N]
answer the card's open wait, in words or by choice
answer <id> --answer A --answer A
answer its questions one by one, in order ("" leaves one unanswered)
answer <id> --skip
skip the questions: the card moves on unanswered
waits <id>
the questions the card has asked, and the answers
new-field <board> <name> --kind K
add a custom field (K: number rating select date text url checkbox person formula)
[--options "Small=1, Large=3"] [--formula "{value} / {effort}"] [--sum]
[--on-cards]  show its value on the front of each card
[--several]   a choice field each card can hold several of
delete-field <board> <field>
preset <board> <rice|ice|value_effort>
set a scoring scheme up (inputs + formula)
milestone <board> <name> --date YYYY-MM-DD [--color C]
delete-milestone <board> <id>
new-automation <board> <description...>
write a rule in plain English (the server's AI turns it into a spec; needs an API key there)
new-automation <board> --spec JSON [--name N] [--tree]
add a rule exactly (see `automation-help`;
--spec - reads the JSON from stdin)
new-automation <board> --preset KEY [field=value...] [--name N]
add a ready-made rule, no AI needed (see `automation-presets`), e.g. --preset follow_list column=Doing notify=email
set-automation <board> <rule> [--on|--off] [--name N] [--spec JSON] [--text "..."|-] [--tree|--no-tree]
also watch subcards, or not (--text - reads the rule's words from stdin)
run-automation <board> <rule>
run a timed rule now (forgets what it has done)
delete-automation <board> <rule>
dismiss <alert-id>... | dismiss --all
dismiss alerts (yours only; others keep theirs)
deploy run [--env E] [--tag T] [--note T] [--dir D] [--dry-run] -- <command…>
record a deploy around your deploy command (in CI): asks the board for the environment's last deployed sha, sends the commits since it (git log in --dir, default .), runs the command, records succeeded/failed from its exit code and exits with it. A rollback (HEAD behind the last deploy) says so; a shallow clone is deepened or the fix is named; a last deploy that left the history (rewritten) is warned about, and the commits since the newest one before it are sent. Needs $SLIPDOCK_DEPLOY_TOKEN (and $SLIPDOCK_URL); env defaults to production
deploy start [--env E] [--tag T] [--sha S] [--note TEXT] [--run-url U] [--dry-run]
the same in two steps: prints the deploy's id… (--note, or $SLIPDOCK_DEPLOY_NOTE: a line kept on the deploy, e.g. how its suite passed;
--run-url, or $SLIPDOCK_DEPLOY_RUN_URL: its CI run)
deploy finish --status succeeded|failed [--id N]
…and records how it ended (id from --id or $SLIPDOCK_DEPLOY_ID)
deploy failed --stage build|test|merge|deploy|health [--run-url U] [--env E] [--sha S] [--tag T] [--note TEXT] [--dry-run]
record a release that failed, from CI's failure job: where it failed and its run (--run-url, or $SLIPDOCK_DEPLOY_RUN_URL), with the commits since the last deploy, so each card they name says "Deploy failed at <stage>" until a deploy naming it succeeds. The deploy job's own record of the attempt is the one marked, not a second. A build, test or merge failure isn't a deploy to the DORA numbers
deploy last [--env E]
the environment's last succeeded deploy
deploy backfill --from-tags [--env E] [--pattern 'v*'] [--dir D] [--dry-run]
record past releases: each tag (oldest first) as a succeeded deploy at its date, with the commits since the tag before. Running it again records nothing twice
deploy backfill --from-runs FILE|- [--env E] [--dir D] [--dry-run]
record the deploys CI made that the board missed: each successful run (gh run list --json headSha,createdAt,updatedAt,conclusion) since the last recorded deploy, with the commits since the one before. Running it again records nothing twice
deploy setup <board> [--ci github|gitlab|shell] [--env production,staging] [--card-ref-pattern RE] [--prompt]
track a board's deploys: turns its delivery metrics on, issues its deploy token (shown once) and prints the CI step to paste; --prompt prints a prompt for Claude Code in the repo instead and changes nothing
deploy token <board> [--revoke]
issue (or replace) the board's deploy token, shown once — it records deploys and nothing else; --revoke ends it. Owner only, API token
incident-of <card> <deploy-id> | --clear
say which deploy an incident card was caused by (that deploy counts as a failed change)
runner new <board> --pool P [--scenario daemon|loop|cloud|chatgpt] [--kind K] [--cwd DIR] [--permission-mode M] [--where desktop|cloud] [--repo owner/repo] [--column LIST [--top] [--[no-]wait-while-doing] [--requeue-stuck N]] [--alert] [--verbosity nothing|quiet|normal|verbose] [--instructions TEXT|-] [--before-job CMD] [--after-job CMD] [--hooks prompt|hook] [--[no-]in-progress] [--[no-]assign] [--[no-]commit] [--[no-]push] [--[no-]move-done] [--[no-]complete] [--[no-]percent-100]
connect a runner: prints exactly what to paste (for daemon, the default, a one-time enrolment key, once); --column adds a rule sending that list's cards (--top: its top card, one at a time, in order; its jobs wait while anything is in progress unless --no-wait-while-doing; a card its job leaves in progress goes back on top
--requeue-stuck times, 1 by default, then
is flagged blocked); --alert adds a rule
raising an alert when a job of the pool
times out or its card is put back or
given up on
a job does nothing to its card or repo unless
told: --in-progress, --assign, --commit,
--push (needs --commit), --move-done,
--complete, --percent-100; the shell runners
(server, windows) were retired: refused
runner show <board> <runner>
one runner in full: who made it, its job now, how its jobs ended, its latest jobs, its rules
runner setup <board> <runner>
a runner with a token of its own (a retired shell runner): the steps to move it onto a machine
runner token <board> <runner>
a new token for such a runner, shown once
runner rm <board> <runner>
revoke a runner (its token stops working)
cancel-job <id>
stop a job: a queued one at once, a running one on the runner's next heartbeat
machines
your machines running the runner daemon: state, system, boards, last seen
machine show <id>
one machine: hostname, OS, fingerprint, boards, its ceiling, runners and their probes, refusals and changes
machine rename <id> <name>
rename a machine: the name the pages and the board show (its hostname stays)
machine boards <id> [--add B] [--remove B]
the boards it serves, or change them (each repeatable, ids or codes) without re-enrolling; a board with runners here is removed only after them, and the last only by revoking. The machine's ceiling must list a board too: what it lacks is printed with the command to run there (`slipdock-runner boards add`)
machine revoke <id>
revoke a machine: its key stops working at once
machine update <id>
ask its daemon to look for a newer signed release now
machine setup-prompt <id>
the Set up this machine with Claude prompt: it reads the boards' machine-setup pages, installs and proves; `slipdock-runner setup` launches it
machine add-runner <id> <board> --pool P --dir D
add a runner to the machine for a board it serves: --name, --agent, --permission-mode,
--timeout-minutes, --model, --executor,
--[no-]worktree, --verbosity, --instructions
(- reads them from stdin, lines and all),
--before-hook/--after-hook/--probe-hook (names
the machine defines), --image and --network
on|off (executor container: the machine runs
only an image on its own allow-list); the
machine refuses what is outside its ceiling
machine set-runner <id> <runner> [those]
change a runner: only what you give changes
machine pause-runner <id> <runner>
hand it no job until resumed (its job finishes)
machine resume-runner <id> <runner>
it takes jobs again
machine rm-runner <id> <runner>
remove it: the machine finishes its job, then stops it
machine probe <id> <runner> [--wait]
probe it: the machine checks its directory, agent, gh, skills and CLI and executor, then runs its probe hook; --wait follows it to green, or red with its log (exit 1)
machine enrolment <code>
the machine a `slipdock-runner init` code belongs to: hostname, system, fingerprint, where it asked
machine approve <code> <board>...
approve it, to serve those boards; you own it
machine refuse <code>
refuse it; the machine is told
machine enrol-key <board>... [--label NAME]
a one-time key (24 hours) for `slipdock-runner init --key`, on a machine with nobody at its screen; shown once. --label is the name the machine enrols under (else its hostname)
claim-job <board> --pool P
take the next queued job as this session (prints "nothing queued" when there is none, or why work is held: paused, WIP full…)
pause <board> [--pool P] --reason "…"
hold the board tree's runner work (or one pool's): nothing is claimed and no list_top rule sends a card; running jobs finish. The board owner's
resume <board> [--pool P]
let exactly that pause off again (a person's: refused when run under an agent)
release <board>
Release now, on a board with batched releases: a runner's release job runs the release command for every merged card awaiting release. One at a time: during a release it queues one follow-up, and more join that. The board owner's. A red release holds nothing (#3179): Release now still releases, with a warning naming the failing run, until its fix card merges (and releases); accepted with no code, the fix card clears it and releases nothing. So does a succeeded deploy at the failed sha or past it (#2996)
releases <board>
where its releases stand: the one running, the one queued, the last ended, the cards awaiting
job-progress [<id>] [--step S] [--message NOTE]
renew the job's lease (a session holds it 20 min);
--step says what you're doing now, shown on the job
(Runners panel, job, jobs) and never a comment on
the card. On an epic's job, name the subcard you
are on in it ("#2835 CI running"): that subcard
then shows the job as its loop and reads as
running, not as nobody on it. The
note is also a comment on the card (--message - reads
it from stdin). Without <id>, the runner job in
$SLIPDOCK_JOB_ID. Prints ok or cancel
finish-job <id> --status done|failed|cancelled|timeout [--summary S]
end a job this session claimed (--summary - reads the summary from stdin)
finish-job <id> --status waiting --needs "Q" [--choice X]... [--on EMAIL]
ask a person and park the job in one step; the answer sends the card again (--needs - reads the question from stdin)
save-view <board> <name> [view opts]
save a swimlane configuration
update-view <board> <view> [view opts] [--name N]
change a saved view
delete-view <board> <view>

View options

(swimlanes, save-view, update-view)

--view V
start from a saved view (id or name), then apply the options below
--group A
(table) group rows by an attribute, same values as --rows
--rows A --cols A
axis attribute: none column assignee priority tag flag completed color due_date schedule created updated (default: priority x column; schedule = the due date rolled up from a card's subcards)
--unit U
day | week | month | quarter | year for date axes (default: week)
--sort S [--descending]
position | title | priority | start_date | due_date | created | updated votes | f:<field id>
--show-empty
keep empty groups (and fill gaps between dates)
filters: --tag T... --priority P... --flag F... --column C... --search Q
--kind card|document|page... (what a list holds; page = a wiki page placed in it)
--due overdue|today|week|month|has|none   --open | --done

Values

<board>
numeric id, code, or name (case-insensitive) — 14, qvm-v1-rem, or "QVM V1 Remediation". The code is the board's short name: unique, URL-safe, up to 10 characters, taken from the name and editable.
<column>
numeric id or name, e.g. "In Progress"
priority
none | low | medium | high | critical
flag
flagged | blocked | review | waiting | starred
color
slate red orange amber lime emerald teal sky indigo violet fuchsia rose

Output

--json
print the raw API response as JSON (best for programs)
--url URL API base (default: $SLIPDOCK_URL,
else this host's Tailscale IP :4000)