Change feed across all tables: numbered row changes (`seq`), oldest first, from engine writes
const url = 'https://example.com/datanotes/operations/list_changes/';const options = { method: 'POST', headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'}, body: '{"since":0,"tables":null,"kinds":null,"columns":null,"where":null,"exclude_actor":null,"limit":500,"wait_ms":0}'};
try { const response = await fetch(url, options); const data = await response.json(); console.log(data);} catch (error) { console.error(error);}curl --request POST \ --url https://example.com/datanotes/operations/list_changes/ \ --header 'Authorization: Bearer <token>' \ --header 'Content-Type: application/json' \ --data '{ "since": 0, "tables": null, "kinds": null, "columns": null, "where": null, "exclude_actor": null, "limit": 500, "wait_ms": 0 }'Change feed across all tables: numbered row changes (seq), oldest first, from engine writes
and from hand edits (source: external). Each has table, kind (insert, update, delete, move,
metastore, unreadable), op (the operation that made it), path, row_id, changes ({column: {before, after}}), actor, migration_id. Hand edits are compared in batches (0.7 s after the last vault change, at most 5 s after the first), in the order they happened, renames included. A hand edit that creates, changes, renames or removes a row is checked against the tables’ rules (as check_table does) with the rows that link to it: the last event of each row in the batch has violations ([{path, violations: [{code, column | constraint (the CHECK’s name), index, message}]}]), what the edit breaks (a rule a row already broke is not listed); empty when it breaks nothing, absent when nothing was checked (engine events, a check that failed). A hand edit of metastore.yaml that changes tables’ entries checks every row of those tables: on its metastore event. At most 100 per event; violations_total then counts them all. A note renamed or moved by hand (a row or a plain note) has the links to its old path rewritten across the vault once the vault is quiet (4 s without a change; not while git pulls, rebases or merges; setting repairLinksOnHandMove, on by default), and its move event does not report them as broken_link: that repair’s events (op: repair_links) follow the batch and name the moves in cause ([{path, old_path, seq}], seq of the row’s move event). A hand edit that leaves a row’s front matter unreadable (broken YAML) is a kind: unreadable event with one violation of code unreadable: every read leaves the row out until the note is fixed, and the fix is an update of the row’s last readable state (an insert for a new note). Agents’ tool calls (reported by MCP servers) are kind: tool_call events (call: tool, args, ok, duration_ms, value, served_by), returned only when kinds includes tool_call. Pass the returned
last as since next time (head is the newest number); wait_ms (max 60000) waits for a new change (long poll); limit max 5000. gap: true means
older changes were dropped: re-read the tables. where filters rows as in select_rows (on the values after the change). Per-table versions: table_changes.
Authorizations
Section titled “Authorizations”Request Body
Section titled “Request Body”object
Responses
Section titled “Responses”Done.
object
Matching changes, oldest first.
object
Sequence number.
ISO date-time.
Qualified table, or null for a note outside any table.
The kind of change: insert, update, delete, move, metastore (metastore.yaml), tool_call, or unreadable (a hand edit left the row’s front matter unreadable).
The operation that made it (insert_row, update_row, undo_migration, repair_links, …); absent for hand edits.
Previous path (move).
Row id.
Changed columns: {before, after}.
object
object
Any JSON value.
Any JSON value.
Row values after the change (before it, for a delete).
object
Who made the change.
object
MCP session id.
App running the agent.
Model id reported by the agent.
Tool the agent called.
Credential: owner, or the name of the token that made the request.
Journal id of the engine operation.
The MCP tool call, for kind tool_call.
object
object
The result, or the error text (long values cut).
The result’s top-level scalars, and lists as their length.
object
“engine”, or the MCP server that ran a tool of its own.
External insert / update / move / delete (the last event of the row in its batch): what the edit breaks, the row’s rules and those of the rows linking to it (a rule broken before the edit is not listed); external schema event: what the rows of the tables it changed break. Empty when nothing is broken; absent when nothing was checked. At most 100 (see violations_total).
The violations of one row.
object
The row that breaks the rule: the edited row or a row linking to it.
object
Kind of violation.
Column the violation is about (all codes but check and unreadable).
The item of a list column, from 0.
The CHECK’s name (code check).
Agent-readable explanation.
How many violations there are in all, when violations holds only the first 100.
An engine write that follows hand edits (operation repair_links: the links repaired after notes were renamed or moved by hand): those moves.
object
The note’s path after the move.
Its path before the move.
The move’s event, when the note is a row.
Pass as since next time.
Newest sequence number.
Events after since were dropped by retention: re-read the tables.
Example
{ "events": [ { "kind": "insert", "source": "engine", "violations": [ { "violations": [ { "code": "required" } ] } ] } ]}Bad input: the body is not a JSON object, or an argument is unknown, missing or of the wrong type.
object
What went wrong, for a person or an agent.
Example generated
{ "error": "example"}Missing or wrong bearer token.
object
What went wrong, for a person or an agent.
Example generated
{ "error": "example"}Unexpected error.
object
What went wrong, for a person or an agent.
Example generated
{ "error": "example"}