Common Ink
All docs

The ink command

ink reads and changes your Common Ink notes from a shell, with an agent's token. This page covers installing it, signing it in, and common tasks, then lists every command.

ink calls the same tools an agent calls over MCP, so it can do what an agent can and nothing more. Its changes are recorded under the agent whose token it uses.

Install it

ink isn't on npm yet. It's coming as the package commonink, and this page will say how to install it when it's out.

Today, ink runs from a copy of the Common Ink source, with Node 22 or later. From the root of that copy:

npm install
npm run ink -- workspaces

The examples on this page use ink. From the source, type npm run ink -- in its place.

Give it a token

ink reads its token from INK_TOKEN. Use an agent's token from Settings, under Agents. Connect an agent shows how to get one, and the limits you set there hold for ink too.

export INK_TOKEN=cink_…
ink workspaces

ink workspaces lists the workspaces the token reaches, with your role in each. INK_URL sets the server and defaults to https://commonink.app.

If you are in more than one workspace, add --workspace with the workspace's id to each command:

ink notes --workspace <workspace id>

Most commands print their answer as JSON. A flag a command doesn't take is refused before anything is sent.

List and read notes

ink folders
ink notes --folder <folder id>
ink read <note id>

ink folders gives each folder's id and its path, such as Projects/Skills. ink folder-find "Projects/Skills" finds one folder by its path. ink read prints the note's markdown, its revision, and the titles of the notes it links to.

Create a note

ink create reads the note's text from stdin, or from --text. Without --folder, the note goes in your Unsorted, in your Private.

ink create --folder <folder id> <<'EOF'
# Groceries

- [ ] Milk
- [ ] Bread
EOF

Search notes and todos

ink search 'budget #money updated:>=7d'
ink todos 'due:<today priority:>=medium'

A query takes words, "a phrase", and filters such as folder:, #tag, is:archived, and due:. ink syntax lists every form, and ink syntax todos lists the forms for todos. Days such as today are counted on this machine's date and time zone unless you pass --today and --zone.

Change some lines of a note

ink edit changes some lines and leaves the rest. Read the note first, and pass its revision as --base. Lines count from 0. --from is included and --to is not.

ink read <note id>
ink edit <note id> --base 4 --from 2 --to 3 --text "- [x] Milk"

With --from and --to equal, the text is inserted there. An empty --text deletes the lines. If someone changed the note since revision 4, ink edit merges your lines with their changes. To replace the whole note, use ink write <note id> --base 4 with the new text on stdin.

Upload and download files

ink upload report.pdf --folder <folder id>
ink download <upload id> --out report.pdf

ink upload sends a file of up to 25 GB in parts, and sends a part again if it fails. It prints the upload and the line that shows it in a note. If it stops, ink upload-resume <upload id> says which parts are stored and gives a fresh address for the rest, and ink upload-abort <upload id> throws the upload away. ink download saves under the upload's name unless you pass --out, and doesn't replace a file that is there unless you add --force true.

Import and export

ink import reads an export from another app on your machine and says what importing it would do, writing nothing. With --write true it does it, as your agent, with your role:

ink import notion-export.zip
ink import notion-export.zip --write true --parent <folder id>

It reads the same files as Settings. A Common Ink export's embeds stay words unless you pass --keep-embeds true. ink import-recent lists the imports of the last day that you or your agents ran, and ink import-remove <id> removes one, leaving notes changed since. ink export saves a copy of what you can see, and --for-other-apps true writes it for other Markdown apps, with links as relative paths.

Revert what an agent changed

ink authors lists everyone who has changed a note, each as a kind and an id, such as agent:abc123def456. Preview first, then revert:

ink authors
ink revert-author agent:abc123def456 --preview
ink revert-author agent:abc123def456

--preview writes nothing. It shows what the revert would do to each note the agent changed. The revert takes out every change of that agent's that still stands, as one new change in each note, and keeps everyone else's changes. Add --note with note ids to revert only those notes.

To look at one note's history and revert chosen changes:

ink history <note id>
ink revert <note id> --changes 7,8 --preview
ink revert <note id> --changes 7,8

A revert is a change like any other, so you can revert it too. History and blame explains reverts and conflicts.

All commands

Usage: ink [--workspace ID] <command>

  workspaces                          the workspaces you can reach
  agents-file                         the workspace's agents file: how it is organized, as its admins and editors wrote
  members                             everyone in a workspace, with their role
  agents                              the agents and subagents you can mention, and which is you
  subagent NAME                       add a name you work under, and print how to mention it
  subagent-update ID [--name NAME] [--remove true]
                                      rename a name you work under, or remove it, which frees the name
  plugins                             the plugins installed in a workspace, and what each is permitted
  plugin-new NAME [--out DIR]         a new plugin's manifest and code to start from, and the plugin API, written
                                      to DIR/manifest.json, DIR/plugin.js and DIR/PLUGIN-API.md when --out is given
  plugin-validate --manifest TEXT --code TEXT
                                      what installing them would make of them, or why it would be refused
  plugin ID                           an installed plugin's code and its codeHash
  plugin-install --manifest TEXT --code TEXT [--replaces ID] [--personal]
  plugin-install --listing ID --version V [--digest D] [--replaces ID] [--personal]
                                      install a plugin, or update one (an admin's agent only, once an admin approves);
                                      --personal installs it for your member alone, at once, to turn on in the app
  plugin-uninstall ID                 take a plugin out of the workspace (an admin's agent only, once an admin approves),
                                      or your member's own personal install, at once
  plugin-permit ID --capability NAME --allowed true|false [--locked true|false] [--origins SITE,SITE]
        [--code-hash HASH]            decide one capability (an admin's agent only, once an admin approves); allowing names the code
  plugin-policy --publish members|admins
                                      who publishes and forks in the store (an admin's agent only, once an admin approves)
  plugin-request ID --capability NAME [--origins SITE,SITE]
                                      ask an admin to allow a plugin one capability
  plugin-proposals                    your requests to change plugins, and whether an admin answered them
  store [QUERY] [--limit N] [--after NEXT]
                                      the listings in the store a workspace can see, such as: timer -is:built-in
  listing ID                          one listing in the store, with every version
  listing-version ID --version V      one version's manifest and code, once its digest is checked here
  plugin-publish --manifest TEXT --code TEXT [--listing ID] [--visibility private|workspace|public] [--notes TEXT]
                                      publish a plugin to the store, or a new version of your member's listing;
                                      a new one is private, your member's alone, unless --visibility says otherwise
  plugin-unpublish ID                 take your member's listing out of the store; installs keep their copy
  plugin-fork ID [--version V] [--name NAME] [--visibility private|workspace|public]
                                      fork a listing, built-in:ID or plugin:ID, as a new listing of your member's
  plugin-changes                      your member's unpublished changes to their own listings
  plugin-changes-read ID              the unpublished changes to one listing of theirs, with the code and what went wrong trying them
  plugin-changes-save ID --manifest TEXT --code TEXT [--base TIME|null]
                                      keep your member's next version of their listing; only they try it, in the app.
                                      --base is the updatedAt you read, or null for none: refused if they changed since
  plugin-changes-discard ID           remove your member's unpublished changes to a listing for good
  notes [--folder ID] [--subfolders true] [--since TIME] [--tag NAME] [--archived true|only] [--fields KEY,KEY] [--limit N] [--after NEXT]
                                      the notes in a workspace, in one folder (and its subfolders), with a tag, or changed since a time
  search QUERY [--today DAY] [--zone ZONE] [--folder ID] [--archived true|only] [--has-todos true]
        [--sort match|recent|created|title] [--fields KEY,KEY] [--limit N] [--after NEXT]
                                      the notes a query finds: words, "a phrase", and filters such as
                                      folder:Plans, #tag, editor:@me, updated:>=7d, is:archived, has:link,
                                      with -, OR, NOT and ( ). "ink syntax" lists every one. --today and
                                      --zone are this machine's unless given
  tags [--name NAME] [--archived true] [--limit N] [--after NEXT]
                                      the tags of the notes you can see, how many notes have each, and when to use it
  tag-describe NAME --description TEXT
                                      say when to use a tag, as your member asked; an empty TEXT takes it away
  archive ID                          archive a note: kept, and left out of listings; says what your member
                                      wants done with its open todos
  unarchive ID                        bring an archived note back
  trash ID                            move a note to Trash, where it waits 30 days
  restore ID                          bring a note back from Trash, to the folder it was in
  trashed [--limit N] [--after NEXT]  the notes in Trash, and when each is removed for good
  read ID [--revision N] [--from N --to N] [--numbered true] [--headings true]
                                      a note's markdown, and the titles of the notes it links to. --from and --to
                                      read only those lines, and --numbered puts each line's number first, both
                                      counted as edit counts them. --headings lists the note's headings and their lines
  create [--text TEXT] [--folder ID] [--write-id ANY] [--link-titles resolve|resolve-strict|keep] [--mention-names keep] [--new-tags NAME,NAME]
                                      a new note (text from stdin if --text is left out). The same --write-id again returns the first note
  write ID --base N [--text TEXT] [--write-id ANY] [--link-titles resolve|resolve-strict|keep] [--mention-names keep] [--new-tags NAME,NAME] [--on DAY]
                                      replace a note's text (from stdin if --text is left out)
  edit ID --base N (--edits JSON | --from N --to N --text TEXT) [--write-id ANY] [--link-titles resolve|resolve-strict|keep] [--mention-names keep] [--new-tags NAME,NAME] [--on DAY]
                                      change lines of a note and leave the rest. Lines are counted from 0 in the
                                      revision you read: --from is included, --to is not, so they are equal to
                                      insert and an empty --text deletes. --edits is a JSON list of {from, to, text}
  backlinks ID                        the notes that link to a note
  links-rebuild                       make backlinks and the index of todos again from the notes' text
  todos [QUERY] [--today DAY] [--zone ZONE] [--folder ID] [--tag NAME] [--due-from DAY] [--due-to DAY]
        [--no-due true] [--importance N,N] [--assignee WHO]
        [--assigned-to-me true] [--completed true] [--archived true|false] [--note ID] [--sort due|priority|changed|note|text] [--count true] [--limit N] [--after NEXT]
                                      the todos a query finds, such as "due:<today priority:>=medium", or every
                                      open one with none; --query QUERY is the same. "ink syntax todos" lists
                                      what a query can say
  syntax [todos|uploads|email|store]  the query language of search, of todos, of uploads, of email, or of the store
  note-syntax                         how to write a form, a board, a timer, and the rest of what a note can hold
  todo-filters [--archived true|false]
                                      the tags and assignees that todos can be narrowed by
  todo ID --revision N --line N --text LINE [--state STATE] [--importance N] [--due DAY|none] [--words TEXT]
        [--every RULE|none] [--skip true] [--assign WHO]
        [--unassign WHO] [--on DAY] [--new-tags NAME,NAME]
                                      check a todo off, abandon it, put it in the backlog, change it, or
                                      skip a repeating todo to its next due date; STATE is open, done,
                                      abandoned or backlog, and --done true|false is open or done;
                                      ID, both Ns and LINE are from todos
  todo-history ID --revision N --line N --text LINE
                                      each time a repeating todo was checked off, and by whom
  backlog-todos ID                    put every open todo in a note in the backlog, in one change undo takes back
  daily [--on DAY]                    your daily note for a day, made if it isn't there
  daily-find [--on DAY]               your daily note for a day when there is one; nothing is made
  favorites [--archived true]         what your member keeps close at hand
  favorite-add [--note ID | --folder ID | --query Q [--page search|todos]] [--name N]
                                      keep a note, a folder or a search as a favorite
  favorite-update ID [--name N] [--query Q] [--before ID]
                                      rename it, change its search, or move it (--name null gives back its own name, --before null moves it last)
  favorite-remove ID                  take a favorite away
  follow ID                           follow a note for your member, to be told of others' edits
  unfollow ID                         stop following it
  visit                               how far your member has read the changes in the workspace
  learned                             what your member has learned of Common Ink, lesson by lesson
  todos-rebuild                       the same as links-rebuild
  move ID --folder ID [--crossing true]
                                      put a note in another folder; --crossing true moves it into or out of
                                      your member's Private, or between shared folders, which changes who sees it
  uploads [QUERY] [--today DAY] [--zone ZONE] [--archived true] [--limit N] [--after NEXT]
                                      the uploads a query finds, such as "type:image uploader:@me", each
                                      with how many notes show it, or every live one with none; --query
                                      QUERY is the same. "ink syntax uploads" lists what a query can say
  upload FILE [--name NAME]
                                      upload a file of up to 25 GB, yours alone until a note shows it, and
                                      say how a note shows it. It goes in parts, several at once, and a part that
                                      fails is sent again; stopped, upload-resume ID says what is left
  upload-start NAME --size N [--write-id ANY]
                                      begin a file sent in parts: the address each part is PUT to
  upload-resume ID                    the parts of a file being sent that are stored, and a fresh address
  upload-finish ID                    put a file's parts together once all are sent, and make it an upload
  upload-abort ID                     stop sending a file, and throw away its parts
  upload-inline NAME --base64 DATA [--write-id ANY]
                                      upload a small file (4 MB at most), given as base64
  download ID [--out PATH] [--force true]
                                      save an upload's bytes under its name here, or at PATH
  export [--out DIR] [--force true] [--part-bytes N] [--part-files N] [--for-other-apps true] [--private true]
                                      save a copy of every note and upload you can see, in their folders,
                                      as zips in DIR: one, or a part each for a large workspace. With
                                      --for-other-apps true, links are relative paths other apps can follow.
                                      With --private true, only what is in your own Private
  export-plan [--part-bytes N] [--part-files N] [--for-other-apps true] [--private true]
                                      the parts an export comes in, and the address of each
  import FILE [--parent ID] [--write true] [--keep-embeds true]
                                      read an export of Obsidian, Notion, Evernote, Google Keep, Bear, Logseq,
                                      Roam, a zip of Markdown or Common Ink on this machine and say what
                                      importing it would do. With --write true, do it. A Common Ink export's
                                      embeds stay words unless --keep-embeds true
  import-plan UPLOAD                  the same preview of an archive already in the workspace as an upload
  import-run UPLOAD [--parent ID] [--keep-embeds true]
                                      import that archive on the server. plan_import says how large it can be
  import-recent                       the imports finished in the last day, which can still be removed
  import-remove ID                    remove an import, for a day after it finishes. Notes changed since stay
  upload-info ID                      one upload, and the notes that refer to it
  upload-archive ID                   archive an upload: kept, and left out of listings
  upload-unarchive ID                 bring an archived upload back
  upload-trash ID                     move an upload to Trash, where it waits 30 days
  upload-restore ID                   bring an upload back from Trash
  uploads-trashed                     the uploads in Trash, and when each is removed for good
  folders                             the folders in a workspace, each with its path
  shared-with-me                      what other people let you in to, from where you see nothing else,
                                      each folder and note with who shared it
  folder-find PATH                    the folder at a path such as Projects/Skills, ignoring case and accents
  folder-create NAME [--parent ID] [--if-exists return|error]
                                      a new folder; with one of that name there already, ignoring case,
                                      prints that one with "created": false, or refuses with --if-exists error
  folder-rename ID --name NAME        give a folder another name
  folder-describe ID --description TEXT
                                      say what goes in a folder, as your member asked; an empty TEXT takes it away
  folder-move ID [--parent ID] [--crossing true]
                                      put a folder inside another, or at the top of your member's Private
                                      without --parent, --crossing as for move
  folder-delete ID [--into ID] [--crossing true]
                                      delete an empty folder, or with --into one whose notes and
                                      folders go there first, as your member asked; --crossing as for move
  history ID                          a note's changes and who made them
  diff ID --change N                  what one change did to its note, as a line diff
  blame ID                            who wrote each line of a note: the change that last wrote or edited it
  changed [--note ID,ID] [--author KIND:ID] [--by people|agents] [--from TIME] [--to TIME] [--limit N] [--before NEXT]
                                      the notes that changed, latest first, with the lines added and removed in each
  changes [--note ID,ID] [--author KIND:ID] [--not-author KIND:ID] [--by people|agents] [--from TIME] [--to TIME]
          [--limit N] [--before NEXT] [--diffs false]
                                      changes across the workspace, newest first, with diffs
  authors                             everyone who has changed a note
  diffs ID:N,N [ID:N,N ...]           what a selection of changes did, note by note: changes that follow one another as one diff
  revert-many ID:N,N[@AT] [ID:N,N[@AT] ...] [--preview] [--resolve keep|back]
                                      revert changes of several notes, each note as one new change. --preview writes nothing and
                                      prints each note's revision: pass it back as @AT and a note changed since is skipped, not reverted
  label ID --revision N [--name NAME] name a revision, or take its name away without --name
  revert ID --revision N              put a note back to a revision, as a new change
  revert ID --changes N,N             revert chosen changes, as one new change; revert a revert to have its changes again
  revert ID ... --preview             what either revert would do, and each conflict with later changes to the same lines, with nothing written
  revert ID ... --resolve keep|back|JSON --at N
                                      settle the conflicts the preview listed at revision N: keep the later edits, go back to the
                                      lines as they were, or a JSON list with "keep", "back" or {"text": "..."} for each conflict
  revert ID --author KIND:ID --preview [--resolve keep|back|JSON --at N]
                                      what revert-author would do to this one note, with nothing written
  revert-author KIND:ID [--note ID,ID] [--after ID] [--resolve JSON] [--trash-emptied true]
                                      revert every change an author made that still stands; --resolve settles the conflicts of the
                                      notes it names, as {"NOTE ID": {"at": N, "choices": "keep"|"back"|[...]}};
                                      with --trash-emptied the notes that leaves empty go to Trash
  revert-author KIND:ID [--note ID,ID] --preview
                                      what that would do to each note the author changed, with nothing written
  undo ID [--revision N]              take back your latest change to a note, or the change that made revision N
  redo ID [--revision N]              revert your latest undo, or the undo that made revision N, so what it undid stands again
  sources                             your member's data sources: their calendar, contacts and email, and whether each is connected
  events --from TIME --to TIME [--timezone ZONE]
                                      your member's calendar events in a span of time
  event SOURCE EVENT                  an event with all it holds: how it repeats, guests, video call, reminders, Busy or Free, visibility
  event-update SOURCE EVENT --etag ETAG [--title TEXT] [--location TEXT] [--description TEXT]
               [--days DAY,DAY | --start TIME --end TIME] [--calendar ID] [--occurrences this|following|all]
               [--repeat RRULE|none] [--guests EMAIL,EMAIL] [--video true|false] [--reminders MIN,MIN|default|none]
               [--busy true|false] [--visibility default|public|private] [--timezone ZONE] [--notify true|false]
                                      change an event where it is kept; --days makes it all-day, first and last day; nobody is told without --notify true
  event-new SOURCE CALENDAR --title TEXT (--days DAY,DAY | --start TIME --end TIME)
            [--location TEXT] [--description TEXT] [--repeat RRULE] [--guests EMAIL,EMAIL] [--video true|false]
            [--reminders MIN,MIN|default|none] [--busy true|false] [--visibility default|public|private]
            [--timezone ZONE] [--notify true|false]
                                      add an event to one of the calendars events lists; nobody is invited without --notify true
  event-delete SOURCE EVENT --etag ETAG [--occurrences this|following|all] [--notify true|false]
                                      delete an event where it is kept, or for a repeating event, what --occurrences says
  contacts [QUERY]                    your member's contacts, or those matching every word
  email [QUERY] [--attachments true|false] [--from-contacts true|false] [--before TIME] [--before-id ID] [--limit N]
                                      your member's email threads, latest first, or those with a message matching every word, from:, subject: and has:attachment. For the next page, --before is the last thread's lastAt and --before-id its id
  thread ID                           an email thread with every message in it, by its id or one of its messages'
  person WHO [--limit N]              a person's page: the member they are, your member's contacts that are
                                      them, their open todos, and the lines that mention them
  refer SOURCE RECORD                 what a note writes to point at a record: [[event:...]], [[email:...]], or [[person:Name]] for a contact
  record REF                          the event or contact a reference stands for, as it is now
  notes-about SOURCE RECORD           the notes that reference an event, by your member's reference or a teammate's to the same event, and who sees each
  repos                               your member's Git repositories, once they let agents use them
  repo-files SOURCE REPO [--branch BRANCH]
                                      a branch's files, its default branch unless named, and what the working copy changed in it
  repo-read SOURCE REPO BRANCH PATH [--numbered true]
                                      a file as committed, and as the working copy has it if changed, with its version;
                                      --numbered numbers the lines repo-edit counts
  repo-write SOURCE REPO BRANCH PATH [--text TEXT | --delete true]
                                      keep a file's new text in the working copy (from stdin if --text is left out), or delete it
  repo-edit SOURCE REPO BRANCH PATH --base VERSION (--edits JSON | --from N --to N --text TEXT)
                                      change lines of a file in the working copy, counted from 0 in the version
                                      repo-read answered, as edit changes a note's
  repo-discard SOURCE REPO BRANCH [--path PATH]
                                      drop the working copy's change to a file, or every change to the branch
  repo-changes SOURCE REPO BRANCH     each change in the working copy of a branch, with a diff
  repo-commit SOURCE REPO BRANCH --message TEXT
                                      commit every change in the working copy of a branch, once your member lets agents commit
  transactions [WORDS]                your member's transactions, latest first, once they let agents use them: --from, --to, --category, --limit,
                                      with --rules true every category rule and what it catches, and with --match JSON, a rule not yet
                                      saved as {"vendor", "how", "categoryId"}, what it would catch and move
  accounts                            your member's accounts by group with their balances and net worth, once they let agents use them: --days
  sync-banks [--from-bank true]       bring your member's banks up to date now, each not read or asked in the last minute;
                                      --from-bank asks each bank itself, which Plaid charges for: 10 minutes apart, 10 a day
  account-add NAME KIND CENTS         add what your member owns or owes that no bank reports: KIND is home, vehicle, other, mortgage, "car loan", "student loan" or "other debt"
  account-value ID CENTS              give an account your member added a new value, dated today
  account-delete ID [--member-set true|false]
                                      delete an account your member added; one whose latest value they set needs --member-set true
  bank-account ID NAME LAST4 TYPE CURRENCY
                                      add or update an account of a bank you read for your member: TYPE is depository, credit, loan or
                                      investment, with --subtype and in cents --current, --available and --limit
  bank-transactions [JSON]            add or update transactions of your bank accounts, all or none: a JSON list of {"id", "accountId",
                                      "date", "cents", "vendor", "category", "status"}, each with "holder" and "replaces" if you like,
                                      and with --removes ID,ID remove pending ones of yours that fell away
  transaction-category SOURCE ID      put one transaction in a category: --category, or without it take that back
  transaction-note SOURCE ID          write what one transaction was: --note, or without it take the note away
  vendor-category VENDOR [--how has] [--existing move]
                                      make or change a rule that puts a vendor's transactions dated today or later in a category,
                                      leaving those already there: --category, or without it take the rule back. --how has takes
                                      VENDOR as words in a vendor's name, and --existing move also moves those it catches now, but
                                      what was filed one by one
  category-add NAME                   add a category
  category-rename ID --name NAME      rename a category
  category-merge ID --into ID         move everything in a category to another
  category-delete ID                  delete a category no transaction is in
  envelopes [--month YYYY-MM]         your member's envelope budget in a month, this one unless given, once they let agents use envelopes
  envelope-history ID                 an envelope's balance at the end of each day it changed, and what each month filled, spent and moved
  envelope-add NAME                   add an envelope, last, with no share, minimum or target
  envelope-set ID [--name NAME] [--percent-bp N] [--minimum-cents N] [--categories IDS] [--target-month YYYY-MM --target-cents N]
                                      change how an envelope is set up, only what is given: --percent-bp is its share of each paycheck
                                      in hundredths of a percent, --categories every category it takes, comma-separated, "" for none,
                                      and --target-cents null takes the target away from --target-month on
  envelope-delete ID                  delete an envelope no charge is filed in, what is in it going to unassigned
  envelope-move FROM TO CENTS         move cents from one envelope to another, either one unassigned
  envelope-propose SOURCE ID --split JSON --confidence N --reason TEXT
                                      propose how your member files a charge, which waits for them or, as they chose, is
                                      filed at once unless their rule or category proposes it (envelopes says which): --split is a JSON list
                                      of {"envelopeId", "cents"}, an envelopeId a holding's id from envelopes for money paid
                                      from it, and --confidence from 0 to 1
  envelope-rule VENDOR [--shares JSON]
                                      split a vendor's later charges, which only proposes: --shares is a JSON list of
                                      {"envelopeId", "bp"} adding up to 10000, or without it take the rule back
  holdings                            what your member keeps some accounts for: an emergency fund, holding for purchases or saving up,
                                      with each one's balance, goal and allocations, once they let agents use holdings
  holding-set SOURCE ACCOUNT [--kind emergency|holding|saving] [--goal-cents N|null] [--allocations JSON]
                                      keep an account as a holding, or change one, only what is given: --allocations is a JSON
                                      list of {"name", "cents"}, all of a holding account's, and --goal-cents null takes the goal away
  holding-remove SOURCE ACCOUNT       stop keeping an account as a holding, with its goal and allocations

A command that changes a note takes --as NAME, the subagent of yours doing it, and history says so.
A flag a command doesn't take is refused, and nothing is sent. A --manifest or --code that starts
with @ is read from the file it names, such as --code @plugin.js.

TIME is anything a date parses, such as 2026-10-09 or 2026-10-09T14:00:00Z. KIND:ID is an author
from authors, such as agent:abc123def456. NEXT is the next of the page before, as JSON.

A link to a note is [[ID]] or [[ID|display text]]. Write [[Title]] and create and write store it by
the id of the one note with that title. When none or several have it, the link stays as written and
the answer lists it in "unresolved"; --link-titles resolve-strict refuses instead, and keep leaves
every link as written. A day is [[YYYY-MM-DD]], a folder [[folder:ID]], an event [[event:REF]] and a
person [[person:ID]] or [[person:Name]], an agent [[agent:ID]], each with |display text to show other words.

Times in answers are ISO 8601 with your member's time zone offset, such as 2026-10-15T09:30:00.000-07:00.

A mention of a person is [[person:ID]] for a member, with ids from members, and [[person:Name]] for anyone
else. An agent or subagent is [[agent:ID]], with ids from agents. Write a name for a member or an agent and
create and write store it by their id, or refuse when several have the name. [[agent:Name]] with a name
nobody has is refused: run agents. --mention-names keep leaves every mention as written. On a todo's line a mention assigns the todo. WHO is a member's id, an agent's, or a name.
A mention gives nobody access.

A #tag tags the note it is in. Use the tags that tags lists: create, write, edit and todo refuse a tag
no note you can see has, unless --new-tags names it, which is for a new tag your member asked for.

A todo is a checkbox line in a note, with its options on the line: - [ ] !! Call the bank due:2026-10-14
Its box says its state: [ ] open, [x] done, [-] abandoned, [>] backlog.
DAY is a calendar date, YYYY-MM-DD. --importance is the priority: 0 for None, 1 Low (!), 2 Medium (!!), 3 High (!!!).
RULE is how a todo repeats, written every:RULE on its line:
  2w (d, w, m or y)   every N after the due date     3d-after-done      N after it was last done
  mon,thu             those days of every week       2w-mon,thu         of every 2nd week
  3rd-day last-day    that day of every month        2nd-tue last-fri   that weekday of every month
  1st-day,15th-day    several of either, in order    3m-last-fri        of every 3rd month
  mar-1               that date every year           1st-mon-mar        that weekday of that month
  then -until-DAY (none after that day) or -times-N (N more times, counting the one due now)
Checking off a todo that repeats leaves it open with its next due date and files the checked line on
your daily note for --on, or for today when left out. Its last time checks it off for good.

SOURCE is a data source's id from sources, such as google-calendar. EVENT and RECORD are ids from
events and contacts, quoted when they have a space. A reference is your member's alone: nobody else
who reads the note can follow it.

A note shows an upload with a line of its own: /image(ID WIDTHxHEIGHT), /video(ID WIDTHxHEIGHT),
/audio(ID) or /file(ID). upload prints the line for the file it sent. A file can be at most 25 GB,
and download never replaces a file that is there unless --force true.

Set INK_URL (default https://commonink.app) and INK_TOKEN (an agent token from Common Ink).