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. 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.

Last-resort email + OTP bind for this MCP session (headless only). Prefer account-level Cursor Connect (Cloud / Grok Bot inherit it) or a ``tsk_`` header. Do not call this as the first hop. When the host has no token: 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``.

Latest nightly dream report for this org (what changed overnight). Returns the most recent leftover-distill + curator report, or ``found=false`` when last night wrote nothing. The same note is a normal semantic memory / wiki page ``memory_recall`` can find.

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``. 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``. Default recall is current truth (superseded/merged rows are omitted); pass ``include_superseded=true`` for the replacement chain.

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 (PII, injection screening, near-dupe merge / contradiction supersede) 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``.

Propose a skill/playbook rewrite from a human-approved draft vs kept. Stores the pair as a pending rewrite. The live skill does not change. A human accepts or rejects the proposed diff in the console; accept writes vN+1 through the existing setter. Never auto-overwrites.

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

Resolve a playbook's ``tool_recipe.skills`` refs to full skill records.

Insert a new version of a skill. Each call creates a new version. Skills are atomic instruction building blocks. Playbooks compose them via ``tool_recipe.skills`` on ``memory_procedure_set``. Routed through the guarded ingestion pipeline; only ``active`` skills are visible to recall and ``memory_skill_get``.