Ir al contenido
Strata
Iniciar sesión

Referencia de comandos de la CLI

Referencia completa de los 55 comandos de strata, generada directamente desde la propia CLI. Lo que lees aquí es exactamente lo que imprime --help.

¿Buscas instrucciones de instalación? Consulta Instalación de la CLI.

Comandos

Flags globales

Aceptados por todos los comandos, en cualquier posición.

ArgumentoValoresDescripción
--api-url <API_URL>?predeterminado: https://api.strata.spaceStrata API base URL

Variable de entorno: STRATA_API_URL

--token <TOKEN>?-Authentication token (overrides keychain)

Variable de entorno: STRATA_TOKEN

--json?-Output as JSON (for CI pipelines)

#strata login

strata login [OPTIONS]

Log in to Strata via browser-based OAuth.

Opens your default browser to complete authentication. Detects SSO from your email domain and routes to your IdP if configured.

On a remote, SSH, or headless host (no local browser), prints a URL and prompts you to paste back the code shown in the browser. Pass --no-browser to force that flow.

Examples:

strata login
strata login --email you@company.com
strata login --no-browser
ArgumentoValoresDescripción
--email <EMAIL>?-Email address (used to detect SSO and skip the Cognito login page)
--no-browser?-Print a URL and paste the code manually instead of opening a local browser and listening on a loopback port. Use on remote/SSH/headless hosts where the browser cannot reach this machine

#strata logout

strata logout [OPTIONS]

Log out of Strata and remove the stored OAuth token.

Clears the token from the OS keychain. Does not affect tokens passed via --token or the STRATA_TOKEN env var.

Example:

strata logout

#strata status

strata status [OPTIONS] [FOLDER]

Show the current state: logged-in user, API URL, active mounts, and linked folders.

Pass a folder to show that folder's live-sync detail instead.

Examples:

strata status
strata status ~/notes
ArgumentoValoresDescripción
[FOLDER]?-Synced folder to show detailed live-sync status for (omit for the overview)

#strata spaces

strata spaces [OPTIONS]

List accessible Spaces.

Without any flags, lists all Spaces you have access to.

Examples:

strata spaces                              # all your Spaces
strata spaces --scope personal              # all personal Spaces
strata spaces --scope org --scope-id tenant_01JAB...     # Spaces in one org
ArgumentoValoresDescripción
--scope <LEVEL>?company | org | team | personalFilter by scope level
--scope-id <SCOPE_ID>?-Scope entity ID (requires --scope)
--limit <LIMIT>?predeterminado: 50Maximum results per page

#strata sync

strata sync [OPTIONS] <COMMAND>

One-time pull or push of Space documents to/from a local directory as Markdown files. Each invocation copies the current state and exits — no background process, no live updates. For a live, two-way folder kept in sync, use strata link.

By default, push is flat: newly created documents land at the Space root, regardless of local subdirectories (existing documents are updated in place and keep their current folder). Pass --folders to recreate the directory tree as Strata folders and file new documents into them. (Pull always materializes server folders as local subdirectories, so a pull/edit/push round-trip without --folders flattens the result.)

Examples:

strata sync pull <space_id> ./notes          # download Space as .md files
strata sync push <space_id> ./notes          # upload changed files (flat)
strata sync push <space_id> ./notes --folders # upload, preserving folders

#strata sync pull

strata sync pull [OPTIONS] <SPACE> <DIR>

One-time download of Space documents as .md files

ArgumentoValoresDescripción
<SPACE>-Space ID
<DIR>-Output directory
--force?-Overwrite existing files

#strata sync push

strata sync push [OPTIONS] <SPACE> <DIR>

One-time upload of changed .md files back to a Space

ArgumentoValoresDescripción
<SPACE>-Space ID
<DIR>-Directory containing .md files
--force?-Skip confirmation prompt
--folders?-Recreate local subdirectories as Strata folders and file new documents into them. Without this, newly created documents land at the Space root regardless of local subdirectories

#strata sync pause

strata sync pause [OPTIONS] [FOLDER]

Pause background syncing without removing any link.

Pass a synced folder to pause just that link, or --all to pause every linked folder at once (each link keeps its own pause state, so resume --all restores exactly what was running before).

Pass --for to auto-resume after a preset window; the agent resumes on its own, even across restarts.

Examples:

strata sync pause ./notes
strata sync pause --all
strata sync pause --all --for 1h
ArgumentoValoresDescripción
[FOLDER]?-The synced folder to pause (omit with --all)
--all?-Pause every linked folder
--for <WINDOW>?30m | 1h | tomorrowAuto-resume after this window instead of pausing indefinitely
  • 30m 30 minutes
  • 1h One hour
  • tomorrow Until the next local midnight

#strata sync resume

strata sync resume [OPTIONS] [FOLDER]

Resume background syncing, or confirm a held bulk deletion.

For a paused folder (or --all for the global pause), resumes syncing. For a running folder whose mass-delete guard tripped — deleting many files at once would unlink a large fraction of the Space's documents — confirms the held deletions and lets sync continue. Unlinking removes documents from the Space only; they still exist and can be re-added.

Examples:

strata sync resume ./notes
strata sync resume --all
ArgumentoValoresDescripción
[FOLDER]?-The synced folder to resume (omit with --all)
--all?-Clear the global pause

#strata mount

strata mount [OPTIONS] <SPACE> <MOUNTPOINT>

Mount a Space as a live filesystem (FUSE on Linux, FSKit on macOS).

Documents appear as Markdown files; edits sync to the API as you make them and remote changes appear locally. Runs in the background until you strata unmount. For a one-time snapshot in either direction, use strata sync instead.

Defaults to read-write. Pass --readonly to mount read-only.

Examples:

strata mount <space_id> ~/strata
strata mount <space_id> ~/strata --readonly
strata mount <space_id> ~/strata --foreground
ArgumentoValoresDescripción
<SPACE>-Space ID to mount
<MOUNTPOINT>-Mountpoint directory
--foreground?-Run in the foreground (blocks until unmounted)
--readonly?-Mount read-only (default: read-write)

#strata unmount

strata unmount [OPTIONS] [TARGET]

Unmount a previously-mounted Space.

With no argument, unmounts the only active mount. Otherwise accepts either a Space ID or the mountpoint path.

Examples:

strata unmount                 (when exactly one Space is mounted)
strata unmount <space_id>
strata unmount ~/strata
ArgumentoValoresDescripción
[TARGET]?-Space ID or mountpoint path. Omit to unmount the only active mount

#strata agent

strata agent [OPTIONS] <COMMAND>

Manage the Strata background agent.

One per-user agent supervises every linked folder (and keeps the login session fresh); link commands install and start it automatically. This group is the explicit lifecycle surface.

Examples:

strata agent status
strata agent restart
strata agent run --replace      (attached to this terminal, for debugging)

#strata agent status

strata agent status [OPTIONS]

Show agent liveness, version, and supervision state

#strata agent install

strata agent install [OPTIONS]

Install (or repair) the agent and its login supervision unit

#strata agent upgrade

strata agent upgrade [OPTIONS]

Upgrade an already-installed agent to this CLI's version (no-op when none is installed)

#strata agent restart

strata agent restart [OPTIONS]

Restart the agent (the one-click repair)

#strata agent uninstall

strata agent uninstall [OPTIONS]

Stop the agent and remove its supervision unit (links and credentials are kept)

#strata agent run

strata agent run [OPTIONS]

Run the agent attached to this terminal (debugging)

ArgumentoValoresDescripción
--replace?-Stop the supervised agent first and hand back on exit

#strata memory

strata memory [OPTIONS] <COMMAND>

Use a Strata Space as a coding agent's long-term memory.

Bind a repository to a Space, then let the agent's lifecycle hooks (the strata-memory plugin for Claude Code / Codex) drive the loop: hybrid-search recall on every prompt, plus a stop-time nudge when session work changed files but no relied-upon memory document was updated.

Human verbs:

strata memory init                 # pick a Space interactively
strata memory bind <space_id>      # bind this repo (add --scope project to commit)
strata memory status               # show binding + effective config
strata memory unbind               # remove the binding

Hook verbs (preflight, recall, check, observe) read the host's hook JSON from stdin, print hook-protocol JSON, and always exit 0.

#strata memory bind

strata memory bind [OPTIONS] <SPACE>

Bind this repository to a Space as its agent memory

ArgumentoValoresDescripción
<SPACE>-Space ID (space_...)
--scope <SCOPE>?user | projectWhere the binding persists: personal (user) or committed (project)
  • user Personal, machine-local binding (nothing committed)
  • project Committed `.strata/memory.json` at the repo root, shared with the team
--strictness <STRICTNESS>?off | nudge-once | strictStop-nudge strictness override for this binding

#strata memory init

strata memory init [OPTIONS]

Interactively pick an accessible Space and bind it

#strata memory unbind

strata memory unbind [OPTIONS]

Remove this repository's memory binding

ArgumentoValoresDescripción
--scope <SCOPE>?user | projectRemove only this scope (default: project first, then user)
  • user Personal, machine-local binding (nothing committed)
  • project Committed `.strata/memory.json` at the repo root, shared with the team

#strata memory status

strata memory status [OPTIONS]

Show the resolved binding and effective memory-loop config

#strata memory preflight

strata memory preflight [OPTIONS]

SessionStart hook: verify auth + binding, seed the session ledger (stdin: hook JSON)

#strata memory recall

strata memory recall [OPTIONS]

UserPromptSubmit hook: search the bound Space, inject candidates (stdin: hook JSON)

#strata memory check

strata memory check [OPTIONS]

Stop hook: nudge once if memory was not reconciled (stdin: hook JSON)

#strata memory observe

strata memory observe [OPTIONS]

PostToolUse hook: record memory documents the agent read (stdin: hook JSON)

#strata api

strata api [OPTIONS] <COMMAND>

Direct API access for scripts, automation, and LLM agents.

Three layers:

- Typed subcommands (documents, spaces) wrap common operations.
- Discovery (list, describe, openapi) walks the embedded OpenAPI
  spec so an agent with no prior knowledge can find any endpoint.
- `api raw` then executes any endpoint by method + path.

Discover-then-call workflow:

strata api list                            # all tags
strata api list Documents                  # operations in a tag
strata api describe update_document        # full schema for one op
strata api raw PATCH /api/v1/documents/doc_01J... --body @edit.json

Typed shortcuts:

strata api documents list
strata api documents create --title "Notes" --content "# Hello"

#strata api documents

strata api documents [OPTIONS] <COMMAND>

Document operations

#strata api documents list

strata api documents list [OPTIONS]

List documents

ArgumentoValoresDescripción
--folder-id <FOLDER_ID>?-Folder ID (optional)
--limit <LIMIT>?predeterminado: 20Maximum results

#strata api documents get

strata api documents get [OPTIONS] <DOC_ID>

Get a document by ID

ArgumentoValoresDescripción
<DOC_ID>-Document ID

#strata api documents content

strata api documents content [OPTIONS] <DOC_ID>

Get document content (markdown)

ArgumentoValoresDescripción
<DOC_ID>-Document ID
--format <FORMAT>?markdown | raw | jsonOutput format
  • markdown Markdown export
  • raw Plain text with all formatting stripped
  • json The `ProseMirror` JSON content response

#strata api documents create

strata api documents create [OPTIONS]

Create a new document

Code blocks tagged html render as live sandboxed previews (vetted libs: mermaid, d3, three, doom) — guide: <https://strata.space/documentation#interactive-html>

ArgumentoValoresDescripción
--title <TITLE>-Document title
--content <CONTENT>?-Content (markdown). Accepts an inline string, @path/to/file.md (read from file), or - / @- (read from stdin)
--folder-id <FOLDER_ID>?-Folder to create the document in. Omit to use your personal (owner-only) folder; pass a tier folder to share with its members. List options with strata api folders list

#strata api documents edit

strata api documents edit [OPTIONS] <DOC_ID>

Edit a document (replace all content)

Code blocks tagged html render as live sandboxed previews (vetted libs: mermaid, d3, three, doom) — guide: <https://strata.space/documentation#interactive-html>

ArgumentoValoresDescripción
<DOC_ID>-Document ID
--content <CONTENT>?-New content (markdown). Accepts an inline string, @path/to/file.md (read from file), or - / @- (stdin). Omit the flag to read from stdin (back-compat shorthand)

#strata api documents move

strata api documents move [OPTIONS] <DOC_ID>

Move a document to a different folder, changing who can see it.

A document's audience is its folder: a personal folder is owner-only, a tier folder is visible to that tier's members.

ArgumentoValoresDescripción
<DOC_ID>-Document ID
--folder-id <FOLDER_ID>?-Destination folder ID (audience becomes that folder's scope)
--to-root?-Move to the space root instead of a folder

#strata api documents delete

strata api documents delete [OPTIONS] <DOC_ID>

Delete (trash) a document

ArgumentoValoresDescripción
<DOC_ID>-Document ID

#strata api folders

strata api folders [OPTIONS] <COMMAND>

Folder operations (a document's audience is its folder)

#strata api folders list

strata api folders list [OPTIONS]

List folders and their scopes (the audience a document gets in each)

ArgumentoValoresDescripción
--parent-folder-id <PARENT_FOLDER_ID>?-Only list the children of this folder
--limit <LIMIT>?predeterminado: 50Maximum results

#strata api folders create

strata api folders create [OPTIONS]

Create a new folder

ArgumentoValoresDescripción
--name <NAME>-Folder name
--parent-folder-id <PARENT_FOLDER_ID>?-Parent folder ID (omit for a top-level folder)

#strata api spaces

strata api spaces [OPTIONS] <COMMAND>

Space operations

#strata api spaces list

strata api spaces list [OPTIONS]

List spaces

ArgumentoValoresDescripción
--scope-type <SCOPE_TYPE>?-Scope type (personal, team, org, company)
--scope-id <SCOPE_ID>?-Scope entity ID
--limit <LIMIT>?predeterminado: 50Maximum results

#strata api spaces get

strata api spaces get [OPTIONS] <SPACE_ID>

Get space info

ArgumentoValoresDescripción
<SPACE_ID>-Space ID

#strata api spaces documents

strata api spaces documents [OPTIONS] <SPACE_ID>

List documents in a space

ArgumentoValoresDescripción
<SPACE_ID>-Space ID
--limit <LIMIT>?predeterminado: 50Maximum results

#strata api spaces add-documents

strata api spaces add-documents [OPTIONS] <SPACE_ID> <DOCUMENT_IDS>...

Add documents to a space

ArgumentoValoresDescripción
<SPACE_ID>-Space ID
<DOCUMENT_IDS>...-Document IDs to add

#strata api list

Alias: ls

strata api list [OPTIONS] [TAG]

List API surface — tags, or operations within a tag.

strata api list — every tag with operation count strata api list <tag> — operations under that tag

ArgumentoValoresDescripción
[TAG]?-Optional tag name. Omit to list every tag

#strata api describe

Alias: show

strata api describe [OPTIONS] [QUERY]...

Show the full schema for one operation: parameters, request body, responses.

Accepts either an operationId or a "METHOD /path" pair.

Response schemas are inlined shallowly by default to keep output small; pass --full to deep-resolve them.

Examples:

strata api describe update_document
strata api describe "GET /api/v1/spaces"
strata api describe list_comments --full
ArgumentoValoresDescripción
[QUERY]...?-operationId, or "METHOD /path" (quote because it contains a space)
--full?-Deep-resolve response schemas too (default: response $refs are left as named references to keep output bounded)

#strata api openapi

strata api openapi [OPTIONS]

Dump the embedded OpenAPI spec to stdout (for offline tooling)

#strata api raw

strata api raw [OPTIONS] [METHOD] [PATH]

Send a raw HTTP request to any API endpoint.

Use this when the typed subcommands don't cover the endpoint you need. Discover available endpoints first with:

strata api list                            # all tags
strata api list Documents                  # operations under a tag
strata api describe update_document        # full schema for one op
strata api describe "GET /api/v1/spaces"   # or by route

Body sources (--body accepts three forms, avoids shell-quoting pain):

--body '{"k":"v"}'   inline JSON string
--body @file.json     read from file (curl-style)
--body -              read from stdin (also @-)

Examples:

strata api raw GET /api/v1/spaces
strata api raw GET /api/v1/documents/doc_01J...
strata api raw POST /api/v1/spaces --body '{"name":"Notes"}'
strata api raw POST /api/v1/spaces --body @space.json
echo '{"name":"Notes"}' | strata api raw POST /api/v1/spaces --body -
strata api raw DELETE /api/v1/documents/doc_01J...

Output is the response body. JSON is pretty-printed; non-JSON is passed through. Non-2xx responses exit non-zero and print the error body.

ArgumentoValoresDescripción
[METHOD]?-HTTP method (GET, POST, PUT, PATCH, DELETE). Omit to see the discovery hint instead of a clap "required argument" error — helpful for first-time / agent invocations
[PATH]?-API path (e.g. /api/v1/spaces)
--body <BODY>?-Request body. Accepts an inline JSON string, @path/to/file.json (curl-style file ref), or - / @- (read from stdin). Skip the flag for an empty body

#strata completions

strata completions [OPTIONS] <SHELL>

Print a shell completion script to stdout.

Install per your shell's convention. Examples:

strata completions fish > ~/.config/fish/completions/strata.fish
strata completions zsh  > ~/.zsh/completions/_strata
strata completions bash > /etc/bash_completion.d/strata
ArgumentoValoresDescripción
<SHELL>bash | elvish | fish | powershell | zshTarget shell