TeamShared

Turn-end batch: assistant summary + durable writes + optional close. One call replaces the end-of-turn memory_session_append + memory_remember (+ memory_session_close + memory_state_set) sequence. The append self-heals expired sessions; the response's ``session_id`` is authoritative. Returns ``{session_id, turn_count, reopened, memories, closed}``.

Compress a prompt payload before it reaches an LLM. Shrinks JSON tool outputs, logs, and long text using SmartCrusher-lite sampling. Originals are stored in CCR (Redis) with ``ref=`` markers for ``context_retrieve``. Always runs; tune thresholds via ``TEAMSHARED_COMPRESS_*``.

Strip, clean, and compress a non-teamshared tool output for agent context. Trims recall-style payloads, shrinks large JSON/logs, and stores originals in CCR when compressed. Prefer letting MCP middleware handle teamshared tools automatically; call this for Shell, Grep, or other harness tools.

Pre-LLM pipeline: session append → compress incoming history → enrich. Returns compressed ``messages``, optional ``additional_context`` (org memory), ``session_id``, and ``stats``. Use before sending a turn to your LLM when you want teamshared to shrink tool bloat and inject recall. Server-side MCP middleware already normalizes teamshared tool responses; this covers the rest of the prompt.

Retrieve the original content for a compressed block via CCR ref.

Archive a shared file (excluded from active lists) and clean up its bucket mirror (if published). Archived files are retained with full version history for audit; the public ``/s/{share_token}`` route returns 404 for an archived file.

Create a new versioned shared file in the caller's org. Shared files default to private. Call ``file_publish`` to generate the public share URL (``/s/{share_token}``). Each ``file_update`` creates a new immutable version row.

Fetch a shared file with its latest version content. Includes ``public_url`` (the ``/s/{slug}`` link) when the file is published.

List active shared files in the caller's org, newest update first. Each file includes ``public_url`` (the ``/s/{slug}`` link, or ``/s/{share_token}`` if no slug) when published, plus ``slug`` and ``share_token``. Use ``query`` to find a file by title without listing everything — e.g. ``file_list(query="yield vault")``.

Publish a shared file: generate the public share token + slug and URL. Idempotent: returns the existing token/slug if already published. The latest rendered HTML is eagerly pushed to the Railway bucket. The public URL is ``/s/{slug}`` (human-readable, from the title) with ``/s/{share_token}`` as a fallback; both are returned in the response.

Revoke public access to a shared file (visibility back to private). The share token is retained for audit; the public route returns 404. Best-effort removes the mirrored objects from the Railway bucket.

Append a new version to an existing shared file (version = prior max + 1). If the file is published, the new version is eagerly mirrored to the Railway bucket. Old versions are never mutated.

Get a one-time uploader script to push a local file into a shared file. For large local HTML/Markdown files that don't fit inline in ``file_create``/``file_update``. Returns ``upload_url``, ``upload_token``, an ``expires_in_seconds`` TTL, and a self-deleting Python ``script``. Save the script to disk and run ``python3 upload.py /path/to/file``; it reads the file, POSTs it to the server with the one-time token, prints the resulting file id (and public URL if ``publish=true``), and deletes itself on success. The token is single-use and expires in ~10 min. **Update mode:** pass ``file_id`` to append the uploaded body as a new version to an existing shared file (the title is ignored; the existing file's title/slug/share_token are preserved, and the bucket mirror is re-published to the new version when the file is already published). This is the supported way to push a new version of a large file.

Delete a single version of a shared file (destructive, irreversible). Refuses to delete the only remaining version. If the deleted version was the current (latest) one, ``current_version`` is bumped back to the new max and -- when the file is published -- the bucket mirror is re-published to that new current version so the public ``/s/{slug}`` route stays consistent. Returns ``deleted``, ``current_version_changed``, and the updated ``file``.

Liveness + dependency probe. Returns ``{"status", "version", "components": {server, redis, postgres, semantic, distiller, graph, ollama}}``. ``semantic`` is the pgvector + embedder store (post-Mem0). Optional deps report ``"disabled"`` when off and do not degrade overall status. Always cheap; safe to poll on a 10s interval. Used by Docker healthcheck and the ``/health`` HTTP route.

List the Gmail/Slack/Discord integrations this caller may use. Returns each connection's id, kind, name, status, and owning account. Only your own OAuth connections and shared org-scoped connectors are listed — other people's personal connections are not usable by you and are omitted. Use this to discover which integration a ``integration_search`` / ``integration_send`` call should target.

Fetch one message/thread from your connected Gmail/Slack/Discord account. Also ingests the message body as a semantic memory (source='connector'). Content from a personal connection is stored private to its owner; content from a shared org-scoped connector lands in the shared brain.

Live-search your connected Gmail/Slack/Discord account (not memory recall). Returns raw hits from the provider (message id, snippet, from/subject for Gmail; text + channel for Slack/Discord). Reads do not ingest; use ``integration_read`` to fetch + persist a message for future recall.

Send an email (gmail) or post a Slack/Discord message as *your* connected account. Only your own connections (and shared org-scoped connectors) can be used; you can never send as another person. The outgoing action is audited and logged as an episodic timeline event.

Sign this MCP session in with email + OTP (cloud agents / headless). Cursor desktop Connect (browser OAuth) is preferred when available. Cloud agents do not get a host ``mcp_auth`` helper — call this tool instead: 1. ``mcp_auth(email="you@example.com")`` — we email a 6-digit code. 2. Ask the human for the code, then ``mcp_auth(email="you@example.com", code="123456")``. 3. If ``status=need_org``, call again with ``org_id=``. After ``status=authenticated``, later tools on this streamable-HTTP session run as that person. Do not store the code or any token.

Execute a governed ontology action and write an audit log entry.

List recent governed action executions for the org.

Assemble one token-budgeted, cited context pack for a task. Fans recall across semantic, episodic, procedural, skill, strategic, work, working pillars and the optional graph in parallel through the secure retrieval path, then ranks and packs the result into a single sectioned markdown bundle. Use this once at the start of a task instead of issuing serial ``memory_recall`` / ``memory_procedure_get`` / ``memory_graph_related`` calls. Returns ``rendered`` (the pack), ``tokens_used``, ``counts_by_pillar``, and the kept ``records``.

Roll up wiki, memories, graph neighbors, and work for one entity.

Browse the episodic timeline (shared within the org by default).

Soft-delete a semantic/episodic memory by id (requires memory:delete). ``memory_id`` is the ``memory_items`` UUID returned by ``memory_recall`` (post-G2 it is no longer a Mem0 id). Procedural deletes are not supported via this tool.

Soft-delete all active versions of a playbook by name.

Soft-delete all active versions of a skill by name.

Record an explicit relationship in the optional org-scoped graph store. No-op (with a reason) when the graph isn't enabled. Use this when you learn a structured fact like "alice -> works_on -> teamshared" that vector recall would obscure. ``predicate`` must be a registered link type (see ``memory_ontology_list``).

Return entities related to ``name`` via the graph store, up to ``depth`` hops.

Register or update a custom org link type.

List org ontology schema: link types, object kinds, interfaces, action types.

Merge ``drop_slug`` into ``keep_slug`` (remap FKs, delete duplicate).

Register or update a custom org object kind.

Propose a typed ontology entity (active immediately).

Change the object kind of an existing ontology entity.

Alias for ``memory_procedure_get``.

Alias for ``memory_procedure_set``.

Alias for ``memory_procedures_list``.

Fetch a stored playbook by name (and optionally version). Set ``expand_skills=true`` to resolve ``tool_recipe.skills`` into the returned ``steps_md`` / ``content_md`` (same as the background runner).

Insert a new version of a procedure. Each call creates a new version. Playbooks are ordered skill collections: set ``tool_recipe.skills`` and optional ``steps_md`` intro. Routed through the guarded ingestion pipeline. Returns ``status`` (``active`` or ``duplicate``).

List playbooks (latest version of each) in the caller's org.

Hybrid recall across memory pillars within the caller's org. Default scope searches durable pillars only (semantic, episodic, procedural, skill, strategic, work). Pass ``scope=["working"]`` to include this chat's open session turns. Shared brain on durable pillars: pass ``agent="cursor"`` only to narrow semantic/episodic. For entity/competitor questions use a **short keyword anchor** in ``query`` (e.g. ``"mex"``) plus ``repo`` / ``github``. Use ``explain=true``; prefer hits with ``matched_keyword: true``.

Write a durable memory into the caller's org. ``fact`` / ``preference`` / ``note`` -> semantic pillar. ``event`` -> episodic. ``procedure`` / ``skill`` -> rejected; use ``memory_procedure_set`` / ``memory_skill_set``. Routed through the guarded ingestion pipeline (dedup, PII, injection screening) under RLS. When ``repo`` / ``github`` are given the memory is tagged ``repo:<slug>`` / ``github:<owner>/<repo>``.

Append a turn to a working-memory session (self-healing). When ``session_id`` has expired or was closed, a fresh session is opened automatically and the turn lands there; the response then carries the replacement ``session_id`` and ``reopened: true``. Pass ``repo`` (and optionally ``github`` / ``topic``) so reopen preserves workspace scope and updates the state pointer without a manual ``memory_state_set``.

Close a working-memory session. If ``distill`` is true (default), the transcript is queued for the background worker to summarize into durable org-scoped memories.

One-call session bootstrap: recover the active session or open one. Replaces the memory_state_get → memory_session_close → memory_session_open → memory_state_set ritual. Reuses the session in the ``conversation/active-session`` state pointer when it is still open and owned by the caller; otherwise closes it (distilling) and opens a fresh one, updating state. Returns ``{session_id, agent, resumed, soul, soul_linked}``. When the bearer is linked to a human account, ``soul`` is their private compressed identity block for this org (may be empty string if not yet written).

Read session metadata and turns (debug, handoff, append failure recovery).

Open a working-memory session and return a ``session_id``.

Fetch a stored skill by name (and optionally version).