Orbismo

World-scope or entity-scope validation. Set entity_id for entity-scope (default check_types: ["property_gaps"]); omit for world-scope (default check_types: ["property_gaps", "orphaned_entities"]). Returns `{ check_timestamp, total_issues, next_cursor, issues: [{severity, type, description, entity_id?}] }`. There is **no `valid` boolean** — inspect `issues[].severity === "error"` to determine validity for entity-scope calls. `strict_mode` (entity-scope only) emits additional error-severity issues for missing required fields.

audit_world

Creates 1-100 entities in a single call. Pass skip_existing: true to skip entities whose slug already exists (in the DB or earlier in the same batch) instead of failing the whole call; defaults to false (strict — any duplicate fails the entire call). Returns { created, skipped, counts } with skipped items carrying the input fields plus a reason. Validation and duplicate failures are all-or-nothing and list every offending row with its array index in error.details (invalid_rows / duplicate_rows). Limits per entity: name ≤255, description ≤2000 chars, ≤30 tags; properties may nest objects/arrays but is bounded (≤5 deep, ≤100 values, ≤16KB) — put long-form prose in lore, not properties/description. Valid entity types: person, place, event, group, project, interest, item, reference, rule.

create_entities

Adds a lore chunk (long-form prose) to an entity. Keep each chunk to one subject or perspective (~50–150 words is ideal); `title` ≤255, `content` ≤10000 chars — split larger prose into multiple focused chunks. `display_index` controls list order; omit it to append at the end. Put structured facts in entity properties and long-form prose in lore. Returns `{ lore_id, title, word_count, created_at }`.

create_entity_lore

Creates 1-100 relationships in a single call. Stored as directed edges; bidirectional querying is handled at query time. Pass skip_duplicates: true to skip duplicate active edges (existing or in-batch) instead of failing the whole call; defaults to false (strict). Source and target entity types are validated against each relationship type's allowed source/target lists. Call get_world_context (relationship_types) for the valid relationship types AND each type's allowed source/target entity types before composing edges — the type name alone is not enough, since an edge is rejected when the source/target entity types are not in that type's allowed lists. Returns { created, skipped, counts }. Validation and duplicate failures are all-or-nothing and list every offending row with its array index in error.details (invalid_rows / duplicate_rows). Per relationship: properties may nest objects/arrays but is bounded (≤5 deep, ≤100 values, ≤16KB); started/ended ≤64 chars.

create_relationships

Permanently deletes an entity (by slug or UUID). By default (`cascade: false`) the call is REFUSED if the entity still has any relationships — it returns an `ENTITY_HAS_RELATIONSHIPS` error naming the count, so you never silently detach its neighbours. Pass `cascade: true` to delete the entity together with all of its relationships (every edge where it is the source or target). The entity's lore and tags are always removed with it. Optional `reason` is recorded in the audit trail. Returns `{ deleted_entity_id, deleted_at, relationships_removed }`. There is no undo — to retire a single relationship without losing data, prefer update_relationship with `ended` instead.

delete_entity

Permanently deletes a lore chunk from an entity. There is no undo. To revise or restructure prose, prefer update_entity_lore over delete-and-recreate — it preserves the chunk's identity and history. Returns `{ deleted_lore_id, deleted_at }`.

delete_entity_lore

Permanently removes a connection between entities. Reserve for data entry errors — prefer update_relationship with ended to mark a relationship as historical instead.

delete_relationship

Retrieve one or more entities (1..20) with paginated `relationships` and `lore` blocks. Always returns `{ success, retrieved_count, entities: [...] }` even for a single entity_id. Each block has `{ total, returned, items, next_cursor }`. `view: "record"` returns the entity record with block counts only (`items: []`, `next_cursor: null` — the record itself is unchanged); `view: "full"` (default) returns paginated block items. Set `lore.include_content: true` to include full lore prose. Per-block `limit`/`cursor`/`filter` paginate independently. Cursors are signed and bound to filter — mid-page filter changes return STALE_CURSOR. When using `cursor`, pass exactly one entity_id (cursor is per-entity). Relationship rows are lean by default: `relationships.embed_target: "name"` (default) embeds only `entity_id` + `entity_name` (the neighbour type is implied by the id prefix); use `relationships.embed_target: "summary"` to also include `entity_short_description` for each neighbour, or fetch a neighbour with get_entities for its full record.

get_entities

Reads lore chunks (long-form prose) on an entity. Omit `lore_id` to list all chunks as summaries ordered by `display_index` (returns `total_chunks` + `lore_chunks` with `lore_id`, `title`, `word_count`, `display_index`, timestamps — no content); provide `lore_id` to fetch one chunk's full content. To find lore by meaning across entities, use search_lore (semantic); to read lore inline with an entity's record and relationships, use get_entities with `lore.include_content: true`.

get_entity_lore

Returns a world's events in chronological order. Filters: date range (start_year/end_year/start_month/end_month), location_id (events linked to a place), entity_ids (events involving ANY of the listed entities), event_types. All filters combine as AND; entity_ids is OR within itself. view: 'compact' returns {entity_id, name, entity_type} plus the date_* parts; 'summary' (default) adds a `preview` field (the entity's short_description). Cursor-paginated (limit max 100, default 50). Note: currently limited to entity_type 'event' carrying date_* properties; generalizing to other types or custom date schemas is tracked in the temporal-model spike.

get_timeline