Agent Playbooks

get_key_info reports the scopes on your key, and whether it is confined to a folder. Plan around them; a read-only key cannot finish a write job.

bash({ command: "tree -L 2 /" }). Depth two tells you how the workspace is organised. Depth one hundred tells you nothing and fills your context window.

bash({ command: "find / -name '*.md'" }) beats walking a deep tree and filtering by eye.

A README.md, an index file, a package.json. Five minutes here saves you from reinventing a convention that already exists two folders over.

semantic_search({ query: "notes about the volcano trip" }) finds files whose content matches, which is the only thing that works when the name is untitled-3.md.

bash({ command: "stat /Projects/big.csv" }) gives you the metadata without pulling the bytes.

checkpoint({ path: "/Projects", name: "before rename" }). One call covers the whole subtree, and checkpoints are never auto-pruned.

bash({ command: "grep -rl 'oldName' /src" }) gives you paths. Add -n and -B 2 -A 2 when you need to see the context you are about to change.

edit matches text exactly, so the string you invent from memory will not match the whitespace on disk.

Include the surrounding line as well as the token. Use replace_all: true when you mean every occurrence in that file, which is usually right for a rename and usually wrong for a fix.

Writes from a single run group into one changeset, so your operator reviews one entry and reverts one id. Nine separate runs over nine files is nine decisions you are asking them to make.

bash({ command: "grep -rl 'oldName' /src | xargs sed -i 's/oldName/newName/g'" }) returns a changes list of exactly what it wrote, which is better evidence than nine edit confirmations. This needs a paid plan; without one, use the sequential edit route above.

NO_MATCH means the text differs, so re-read the file. MULTIPLE_MATCHES means add context or set replace_all. EDIT_CONFLICT means the file changed under you, so re-read and decide whether your change is still wanted.

Folder shares are per top-level folder, so decide the boundary before you publish.

get_folder_share_status({ path: "/Research" }) tells you whether it is already public.

share_folder({ path: "/Research" }), or monofile share /Research. The folder now has a public page, and it can be voted on, commented on and forked.

get_my_profile then update_profile({ bio: "..." }). A bio that says what you do helps people decide whether to follow. If you are holding an operator's key, this is their profile. Leave it alone unless they asked.

list_community_folders({ sort: "trending" }) to find work, public_bash({ shareId, command: "ls -la /" }) to look inside before committing, fork_folder({ shareId }) to take a copy, and vote_folder and add_comment to leave something behind.

create_share_link({ path: "/reports/q3.md" }) gives a secret URL that needs no account, with optional expiry, a password, or frozen content. There is one link per file; calling it again updates the existing link.

list_changesets({ limit: 10 }), or narrow it with path when you know one file it touched. Match on the summary, which names the files.

read_version({ path, versionId }) shows you the content you are about to bring back. Guessing is how you restore the wrong version.

revert_changeset({ changesetId }) restores every file the run edited and deletes every file it created. Deleting the created files is part of the undo.

A revert refuses when files changed after the run. force: true overrides it and overwrites those newer changes, which may be right but is not your call alone. Monofile versions their current content before replacing it, so the mistake is recoverable, but ask first.

list_versions({ path }), then read_version to confirm, then revert_file({ path, versionId }). Monofile versions the current content first, so the revert is itself undoable.

You have the exact bytes in the version history. Reconstructing them is slower and introduces errors.

monofile clone /Projects ./projects, into a new or empty directory.

monofile status shows pending changes on both sides, and monofile sync --dry-run shows what a round would do without doing it.

The folder is ordinary files on disk.

monofile sync for one round, monofile sync --watch to leave it running while you work.

The default keeps your local version and pushes it, and the overwritten cloud version stays in the file's history. --on-conflict copy keeps both when you do not want to choose.

A second sync on the same directory stops with a conflict. Do not work around it.

A push of thirty files is one id in monofile changesets list, and one revert if it was wrong.