Ontonym

Build (or top up) the vector index a memory's semantic_search reads. `semantic_search` matches against stored embeddings, so a memory that has never been embedded answers every query with ZERO results — indistinguishable from "nothing matches". Run this once per memory, and again after a large ingestion, to make newly added objects findable by meaning. Idempotent: entities already embedded for the current model are skipped unless `force`. `kinds` defaults to ['object', 'class']. Requires write scope. Large memories take a while — this can run for minutes.

"What should I watch out for if I change this object?" — event-class neighbours, actions touching it, property conflicts, top related objects, and provenance. One composite call. `memory` is the slug.

Add a document to the knowledge graph by extracting it YOURSELF, in this chat. STEP 1 of 4. Use whenever the user shares a document/notes/transcript and wants it captured in the graph, and you (this assistant) should do the extraction. `memory` is the slug from list_my_memories. Returns a `passes` list. The flow: (1) run the `classes` pass prompt over the document you already have; (2) run the `objects` pass prompt and draft candidate objects/events; (3) call resolve_names ONCE with every candidate name and reuse each returned canonical name + class; (4) call submit_extraction_from_llm(memory, results). The document is NOT sent to the server, and no object list is embedded in the prompts — resolve_names is how you see what already exists.

Recent ingestions in a memory — what changed lately.

The class-level graph (classes + relationships) of a memory.

Full detail/subgraph for one object in a memory (id from search/list).

Shortest relationship paths between two objects in a memory — the one-call answer to "how are A and B connected?". `start` and `target` accept an object id or an exact name/display name. Each returned path is a list of steps {from, rel, direction, to}; paths are all of minimal length. `found: false` with `frontier_truncated: true` means the search hit its breadth cap, NOT proof the objects are disconnected. Use this instead of chaining get_object calls hop by hop.

List objects of one class in a memory (class_id from list_classes).

List the classes (schema) in a memory (slug from list_my_memories).

List the memories YOU can read and ingest into. Call this first, then pass the chosen `slug` as the `memory` argument to every other tool.

List objects in a memory, optionally filtered to one exact class (by canonical snake_case name; descendants NOT included). Each row carries `status` — defer on 'unapproved'. `memory` is the slug.

Reverse ownership lookup — what objects does this person (object_id) own? Approved ownerships only. `memory` is the slug.

The review queue — rows still status='unapproved', which an agent should defer on. `kind` filters to one of class/property/action/ relationship/rule/flow/flow_step/object/object_property/object_action/ object_relationship/object_flow/object_flow_step; omit to scan all.

Pending-review ownership suggestions in a memory, newest first.

Fold a DUPLICATE object into the object it duplicates, then delete it. Extraction coins near-duplicates (`turkey` beside `country_tur`) because the known-objects hint it sees is capped at the newest rows. Use this when two objects of the SAME class denote one real thing: `winner_id` is the one to keep, and the loser's properties, edges, mentions and ownership move onto it before it goes. Edges the move turns into self-loops or exact duplicates are dropped. Identify the loser by `loser_id` or by `loser_name` (its canonical snake_case name, resolved within the winner's class). Irreversible, and the loser id stops resolving afterwards — confirm the two really are one thing (get_object on both) before calling. Refuses a cross-class pair. Requires write access to the memory.

Queue ONE action for HUMAN APPROVAL — nothing is sent or written until a memory owner approves it in the Agents tab. The kind that makes this powerful from an AI client: `workspace_write` creates a record in the memory's own apps once approved — an issue on the Agile board, a support ticket, a CRM deal, a note. Fields: target=record title, body=record body, extra.class_name=the app class (issue/ticket/deal/note/…), extra.properties=a {property: value} object, extra.relationships=[{type, target_name}]. Outbound kinds (jira_comment, slack_message, gmail_send, …) address connected external tools; see the API's action registry for their fields. `memory` is the slug. Requires write scope.

Drop an ownership row by (object, owner). Idempotent — `removed=false` when the pair wasn't linked. Requires write scope.

Ask which of your candidate names already exist in the memory — call ONCE per document during extraction, after drafting candidate entities and before emitting the final JSON. `items` = [{"kind": "object"|"class", "name": "...", "class_name": "..."?}, ...] (max 200). Each result carries `exact` (case-insensitive name hits) and `matches` (spelling/semantic look-alikes with scores). REUSE a returned canonical `name` + its class instead of creating a duplicate; only names with no hits should be created new. Read-only.

Semantic search over a memory's classes and objects. `memory` is the slug from list_my_memories. `kind` = 'class' | 'object' | omit. Check `status` and defer on 'unapproved'. `expand=1` inlines each top object hit's FIRST RING — properties plus relationship groups with counts and member previews — so you learn what a hit is and what it touches without a get_object per hit. Prefer expand=1 whenever you intend to follow relationships; for reach beyond one ring, use get_paths instead of hopping get_object calls.

Set ownership directly (status='approved'). `role` is 'primary' (demotes any existing approved primary to secondary) or 'secondary'. Requires write scope.

Save the extraction you produced — the LAST step after get_extraction_prompt and your single resolve_names call. `memory` is the slug. `results` maps each pass `key` to that pass's JSON, e.g. {"classes": {...}, "objects": {...}}. `source_doc` is an optional label (filename/title) for provenance. New rows land status='unapproved'. The response may carry `validation_errors` (rows the server could not place — report them to the user instead of ignoring them) and `near_duplicates` (new objects that look like an existing one — review with the user and fold confirmed pairs with merge_objects).

File an ownership SUGGESTION (status='unapproved') for review instead of writing it directly. Idempotent and sticky. Requires write scope.