# TeamShared (remote · teamshared.com)

Shared memory for coding agents. Stop re-explaining your codebase every session.

- Trust score: 64/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-20

## Components

- remote · `teamshared.com`: 64/100 (this document), [markdown](https://verifymcp.io/servers/xhad-teamshared/teamshared.md), [page](https://verifymcp.io/servers/xhad-teamshared/teamshared)

## Channel facts

- Endpoint: `https://teamshared.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.9.1`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-20.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 94 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 81/100
  - AI-judged instruction clarity (excellent).
  - Tool/resource definitions use about 9495 tokens (~101/item across 94 items; 94 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 96% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http xhad-teamshared https://teamshared.com/mcp
```

### Codex

```toml
[mcp_servers.xhad-teamshared]
url = "https://teamshared.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xhad-teamshared": {
      "type": "remote",
      "url": "https://teamshared.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add xhad-teamshared --url https://teamshared.com/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  xhad-teamshared:
    url: "https://teamshared.com/mcp"
```

### Other

```json
{
  "mcpServers": {
    "xhad-teamshared": {
      "type": "http",
      "url": "https://teamshared.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-20 (score 64, 0)

- [functional improvement] Stability: unverified → 0.03

### 2026-08-19 (score 64, +28)

- [security regression] Authorization: pass → unverified
- [security improvement] Transport: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Tool coverage: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 96
- [functional] First check of Schema quality: excellent
- [functional] First check of Schema quality: pass
- [functional] First check of Tool coverage: 100

### 2026-08-18 (score 36)

First indexed and scored.

## MCP tools (94)

### `mcp_auth` (~248 tokens)

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.

Input parameters:

- `code`: One-time code from the login email. Pass together with email= after mcp_auth returned status=code_sent.
- `email`: Email to send a 6-digit login code to. Same OTP as the console and Cursor Connect. Omit (with no code) to see whether this session is already signed in.
- `org_id`: Organization to attach when the email belongs to more than one org (status=need_org).

### `health` (~107 tokens)

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.

### `version` (~163 tokens)

Report server + memory-rule version and whether the rule needs updating.

Returns ``{server_version, rule_version, installed_rule_version,
rule_path, update_available}``. When ``update_available`` is true (the
installed rule is missing or behind the canonical one), the response also
includes ``rule_markdown`` — write it verbatim to your rule file
(Cursor: ``~/.cursor/rules/teamshared.mdc``) to update the user, then
tell them the memory rule was updated. See the rule's "Staying current".

Input parameters:

- `installed_rule_version`: The `version` from your installed teamshared rule's frontmatter (e.g. the value in ~/.cursor/rules/teamshared.mdc). Omit if your rule has no version marker.

### `context_compress` (~108 tokens)

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_*``.

Input parameters:

- `messages` (array, required): OpenAI-style chat messages to compress before sending to an LLM. User messages are preserved; long tool/assistant/system blocks shrink.

### `context_retrieve` (~40 tokens)

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

Input parameters:

- `ref` (string, required): CCR ref from a compressed message (ref=ccr_...)

### `context_prepare` (~222 tokens)

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.

Input parameters:

- `append_session` (boolean): Append the latest user message to the working session.
- `enrich` (boolean): Assemble org memory and append as `additional_context`.
- `github`: GitHub `owner/repo` for scoped recall enrichment.
- `messages`: OpenAI-style chat messages to run through the pre-LLM pipeline. Provide this or `prompt`.
- `prompt`: Latest user prompt when you do not have full message history.
- `repo`: Workspace slug for scoped recall enrichment.
- `session_id`: Working-memory session to append the user turn to.
- `token_budget`: Soft token cap for assembled context.

### `context_commit` (~251 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `close` (boolean): Close the session (queueing distillation) and clear the state pointer. Pass true when the task is done or the user says goodbye.
- `facts`: Durable memories to write in the same call: [{"content": "...", "kind": "fact|preference|event|note", "subject": "...", "tags": [...]}]. Only include things still true next week.
- `github`: GitHub owner/repo tag for the facts.
- `repo`: Workspace slug; scopes fact tags and the state pointer.
- `session_id`: Working-memory session to commit to. Omit to resolve it from the conversation/active-session state pointer (requires repo).
- `summary` (string, required): Faithful summary of your reply — appended as the assistant turn.

### `context_normalize` (~103 tokens)

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.

Input parameters:

- `output` (string, required): Raw tool output string (usually JSON).
- `tool_name` (string, required): Name of the tool whose output you are trimming.

### `memory_tools_catalog` (~170 tokens)

Discover teamshared MCP tools for the current turn.

Returns ``protocol`` (every-turn loop), ``chooser`` (need → tool),
\``never`` (hard constraints), and grouped tools with ``when`` /
\``avoid`` / copy-paste ``example``. Pass ``need=`` when choosing a
tool mid-conversation. Also returns ``tool_recipe_shapes`` and
\``aliases`` (procedure_* → playbook_*).

Input parameters:

- `need`: Conversation router: short intent (e.g. 'share a file', 'live slack', 'create a task'). Returns matching chooser rows plus those tools' when/avoid/example. Omit to browse.
- `scope` (string): memory, work, or all tool groups
- `tier`: Optional filter: core, extended, or human

### `memory_remember` (~318 tokens)

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

Input parameters:

- `agent`: Override agent identity (defaults to bearer-token identity)
- `content` (string, required): Free-form text to remember
- `github`: GitHub repository as owner/repo (e.g. xhad/teamshared). Stored as a 'github:<owner>/<repo>' tag for cross-machine association; use with or instead of workspace repo= when the same GitHub repo is chec…
- `kind` (string): fact, preference, event, or note (not procedure/skill)
- `repo`: Workspace slug of the repo this memory belongs to (e.g. the slug used for memory_state). For code/repo-specific work, pass your current workspace slug so the memory is scoped to this repo (stored as…
- `subject`: Optional subject/entity this memory is about
- `tags`: Optional free-form tags

### `memory_soul_get` (~86 tokens)

Return this person's private soul for the current org.

The soul is a tiny compressed identity block (who they are, style,
likes/dislikes, dos/don'ts). Empty when none yet or the API key is not
linked to a human account (mint keys from the console while signed in).
Also returned on ``memory_session_ensure`` as ``soul``.

### `memory_soul_set` (~91 tokens)

Replace this person's private soul for the current org.

Prefer compact structured markdown. Preferences written via
\``memory_remember(kind=preference)`` also absorb into the soul.

Input parameters:

- `agent`: Override agent attribution label
- `body_md` (string, required): Compressed soul markdown (identity, role, style, likes, dislikes, dos/don'ts, patterns). Keep short; server caps length.

### `memory_recall` (~389 tokens)

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

Input parameters:

- `agent`: Optional filter — restrict semantic/episodic results to this agent's writes. Default (None) is the shared brain: every agent's durable memories in the org are visible. Working memory is always scoped…
- `explain` (boolean): When true, include per-record retrieval attribution in metadata
- `github`: GitHub repository as owner/repo. Boosts memories tagged github:<owner>/<repo> (portable across checkout paths).
- `k` (integer): Max records to return
- `query` (string, required): Natural-language query
- `repo`: Workspace slug of your current repo. When set, durable memories tagged for this repo are boosted (ranked higher); nothing is hidden — cross-repo and un-scoped memories still appear. Pass your workspa…
- `scope`: Pillars to search. Default (null): durable pillars only (semantic, episodic, procedural, skill, strategic, work) — working is omitted. Add scope=['working'] when you need this chat's open session tur…
- `time_range`: Optional time bounds for episodic/working hits
- `verbose` (boolean): When false, truncate record content and omit metadata

### `memory_think` (~173 tokens)

Synthesized answer with citations and gap analysis (GBrain ``think`` parity).

Runs durable recall (default scope excludes working), then composes a
cited prose answer plus explicit gaps. For named-entity or competitor
questions, call ``memory_recall`` with a short keyword anchor first —
synthesis quality depends on retrieval. Prefer ``memory_think`` when
you need prose + gaps after recall surfaced hits, or for open strategic
questions.

Input parameters:

- `github`: GitHub owner/repo; boosts github-tagged memories
- `k` (integer): Max source records to retrieve before synthesis
- `query` (string, required): Question to answer from team memory
- `repo`: Workspace slug; boosts repo-scoped memories in retrieval
- `token_budget` (integer): Approx token budget for source packing

### `memory_assemble_context` (~257 tokens)

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

Input parameters:

- `github`: GitHub repository as owner/repo (boosts github-tagged memories)
- `k_per_pillar` (integer): Max records to recall per pillar
- `open_files`: Paths of files currently open/relevant; their names seed the graph-relationship lookup.
- `repo`: Workspace slug of your current repo. Boosts repo-scoped memories in the pack; pass it for code/repo-specific work.
- `task` (string, required): What you are about to do (the task/question driving recall)
- `token_budget` (integer): Approx token budget for the rendered pack (default 1500)

### `memory_session_open` (~118 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `github`: GitHub repository as owner/repo. Distilled memories inherit a 'github:<owner>/<repo>' tag.
- `repo`: Workspace slug of the repo this session is about. Memories distilled from the session inherit a 'repo:<slug>' tag so they stay scoped to this workspace.
- `topic`: What this session is about (free text)
- `ttl`: Session TTL in seconds (default from server config)

### `memory_session_ensure` (~295 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `fresh` (boolean): Force rotation: close any stored session (queueing distillation) and open a new one. Pass true on the first turn of a new chat.
- `github`: GitHub owner/repo; distilled memories inherit the tag
- `repo` (string, required): Workspace slug (absolute path with leading / removed and / replaced by -). Keys the conversation/active-session state pointer.
- `topic`: What this session is about (used when opening a new one)
- `ttl`: Session TTL in seconds (default from server config)
- `user`: Substantive user request for this turn. When set, appended as the user turn in the same call (replaces a separate memory_session_append).

### `memory_session_append` (~196 tokens)

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

Input parameters:

- `content` (string, required): Turn content
- `github`: GitHub owner/repo tag used when reopening a session
- `repo`: Workspace slug. When set with an active bearer token, reopen self-healing updates the conversation/active-session pointer.
- `role` (string, required): user, assistant, tool, or system
- `session_id` (string, required): Session id from memory_session_open
- `topic`: Session topic used when reopening after expiry

### `memory_session_close` (~75 tokens)

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.

Input parameters:

- `distill` (boolean): Enqueue for distillation into semantic/episodic memory
- `session_id` (string, required): Session id to close

### `memory_session_get` (~38 tokens)

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

Input parameters:

- `session_id` (string, required): Session id from memory_session_open

### `memory_episodes_list` (~87 tokens)

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

Input parameters:

- `agent`: Optional filter — restrict to one agent's episodes. Default (None) returns every agent's timeline in the org.
- `limit` (integer)
- `since`: Lower bound on created_at
- `topic`: Substring match on topic
- `until`: Upper bound on created_at

### `memory_procedure_get` (~97 tokens)

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

Input parameters:

- `expand_skills` (boolean): Inline composed skill bodies into steps_md
- `name` (string, required): Playbook (procedure) name
- `version`: Specific version (default: latest active)

Output parameters:

- `result`

### `memory_playbook_get` (~48 tokens)

Alias for ``memory_procedure_get``.

Input parameters:

- `expand_skills` (boolean): Inline composed skills
- `name` (string, required): Playbook name
- `version`: Specific version

Output parameters:

- `result`

### `memory_procedure_set` (~165 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `description`: One-line summary
- `name` (string, required): Procedure name (stable id)
- `steps_md` (string): Optional intro markdown before composed skills; use tool_recipe.skills for the ordered skill list
- `tags`: Tags for discovery
- `tool_recipe`: Playbook recipe: {"skills": ["lint", "ship-pr"], "loop": {"max_iterations": 3}}. See memory_tools_catalog for full shapes.

### `memory_playbook_set` (~89 tokens)

Alias for ``memory_procedure_set``.

Input parameters:

- `agent`: Override agent identity
- `description`: One-line summary
- `name` (string, required): Playbook name (stable id)
- `steps_md` (string): Optional intro markdown before composed skills
- `tags`: Tags for discovery
- `tool_recipe`: Ordered skill list: {"skills": ["lint", "ship-pr"]}

### `memory_procedures_list` (~65 tokens)

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

Input parameters:

- `include_body` (boolean): Include full steps_md and tool_recipe
- `limit` (integer)
- `offset` (integer): Pagination offset
- `tag`: Filter by tag

### `memory_playbooks_list` (~54 tokens)

Alias for ``memory_procedures_list``.

Input parameters:

- `include_body` (boolean): Include full steps_md
- `limit` (integer)
- `offset` (integer)
- `tag`: Filter by tag

### `memory_forget_procedure` (~47 tokens)

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

Input parameters:

- `name` (string, required): Playbook name to soft-delete
- `reason` (string, required): Audit reason; required

### `memory_skill_get` (~41 tokens)

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

Input parameters:

- `name` (string, required): Skill name
- `version`: Specific version (default: latest active)

Output parameters:

- `result`

### `memory_skill_set` (~142 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `body_md` (string, required): Markdown body the agent will read
- `description`: One-line summary
- `name` (string, required): Skill name (stable id)
- `tags`: Tags for discovery
- `tool_hints`: Optional structured hints (preferred MCP tools, params)

### `memory_skills_list` (~65 tokens)

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

Input parameters:

- `include_body` (boolean): Include full body_md and tool_hints
- `limit` (integer)
- `offset` (integer): Pagination offset
- `tag`: Filter by tag

### `memory_skill_resolve` (~55 tokens)

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

Input parameters:

- `playbook_name` (string, required): Playbook whose skills to resolve
- `playbook_version`: Pin playbook version (default latest)

Output parameters:

- `result`

### `memory_forget_skill` (~44 tokens)

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

Input parameters:

- `name` (string, required): Skill name to soft-delete
- `reason` (string, required): Audit reason; required

### `memory_strategic_statement_get` (~38 tokens)

Fetch the active org statement for vision, mission, or purpose.

Input parameters:

- `kind` (string, required): vision, mission, or purpose

Output parameters:

- `result`

### `memory_strategic_statement_set` (~56 tokens)

Propose a new version of vision, mission, or purpose.

Input parameters:

- `agent`: Override agent identity
- `content_md` (string, required): Markdown body
- `kind` (string, required): vision, mission, or purpose

### `memory_strategic_plan_list` (~43 tokens)

List OKR cycles (strategic plans) for the org.

Input parameters:

- `active_only` (boolean): Only active plans
- `limit` (integer)

### `memory_strategic_plan_get` (~50 tokens)

Fetch one strategic plan, optionally with the full OKR tree.

Input parameters:

- `include_tree` (boolean): Include objectives, key results, initiatives
- `plan_id` (string, required): Plan UUID

Output parameters:

- `result`

### `memory_strategic_plan_set` (~68 tokens)

Propose a new OKR cycle.

Input parameters:

- `agent`: Override agent identity
- `name` (string, required): Cycle name, e.g. 2026 Q2
- `period_end` (string, required): Inclusive end date
- `period_start` (string, required): Inclusive start date

### `memory_strategic_objective_set` (~84 tokens)

Propose an objective under a plan.

Input parameters:

- `agent`: Override agent identity
- `description_md`: Optional description
- `owner_id`: Owner UUID
- `owner_type`: user or agent
- `plan_id` (string, required): Parent plan UUID
- `sort_order` (integer): Display order
- `title` (string, required): Objective title

### `memory_strategic_key_result_set` (~106 tokens)

Propose a key result under an objective.

Input parameters:

- `agent`: Override agent identity
- `description_md`: Optional description
- `metric_current`: Current value
- `metric_target`: Target value
- `metric_unit`: Unit, e.g. %
- `objective_id` (string, required): Parent objective UUID
- `title` (string, required): Key result title
- `track_status` (string): on_track, at_risk, off_track, or done

### `memory_strategic_initiative_set` (~78 tokens)

Propose a strategic initiative.

Input parameters:

- `agent`: Override agent identity
- `description_md`: Optional description
- `key_result_id`: Aligned key result UUID
- `objective_id`: Aligned objective UUID
- `plan_id` (string, required): Parent plan UUID
- `title` (string, required): Initiative title

### `memory_strategic_entity_get` (~50 tokens)

Fetch one strategic entity by type and id.

Input parameters:

- `entity_id` (string, required): Entity UUID
- `entity_type` (string, required): objective, key_result, initiative, plan, or statement

Output parameters:

- `result`

### `work_list` (~130 tokens)

List org work items (shared task queue for humans and agents).

Input parameters:

- `assignee`: Filter by agent name or user email
- `exclude_closed` (boolean): Omit done/cancelled items (default true)
- `initiative_id`: Filter to tasks linked to a strategic initiative UUID
- `limit` (integer)
- `mine` (boolean): Only items assigned to the caller (human or agent)
- `offset` (integer): Pagination offset
- `sort` (string): Sort key
- `sort_dir` (string): asc or desc
- `work_status`: Filter by workflow status

### `work_get` (~26 tokens)

Fetch one work item by id.

Input parameters:

- `work_id` (string, required): Work item UUID

Output parameters:

- `result`

### `work_create` (~229 tokens)

Create a work item. Created active immediately for humans and agents (no approval queue).

Input parameters:

- `agent`: Override agent identity
- `assignee_email`: Assign to org member by email
- `assignee_id`: Assignee UUID
- `assignee_type`: Assignee type (user)
- `description`: Alias for description_md
- `description_md`: Optional markdown body
- `due_at`: Optional due datetime
- `github`: Optional owner/repo tag
- `initiative_id`: Optional strategic initiative UUID
- `item_type` (string): task, milestone, or approval
- `parent_id`: Parent task UUID (makes this a subtask)
- `priority` (string): urgent, high, normal, low
- `project_id`: Add the task to this project UUID
- `repo`: Optional workspace slug tag
- `section_id`: Place in this project section UUID
- `start_at`: Optional start datetime
- `tags`: Optional tags
- `title` (string, required): Short task title
- `work_status` (string): Initial workflow status

### `work_update` (~182 tokens)

Update a work item (status, assignee, priority, parent, etc.).

Input parameters:

- `agent`: Override agent identity
- `assignee_email`: Assign to user by email
- `assignee_id`: Assignee UUID
- `assignee_type`: Assignee type (user)
- `blocked_reason`: Why blocked (when status=blocked)
- `description_md`: New markdown body
- `due_at`: Due datetime
- `github`: owner/repo tag
- `initiative_id`: Strategic initiative UUID
- `parent_id`: Parent task UUID (reparent as subtask)
- `priority`: urgent, high, normal, low
- `repo`: Workspace slug tag
- `tags`: Replace tags
- `title`: New title
- `work_id` (string, required): Work item UUID
- `work_status`: Workflow status

Output parameters:

- `result`

### `work_close` (~46 tokens)

Mark a work item done or cancelled.

Input parameters:

- `agent`: Override agent identity
- `work_id` (string, required): Work item UUID
- `work_status` (string): done or cancelled

Output parameters:

- `result`

### `work_comment_add` (~48 tokens)

Add a comment to a work item.

Input parameters:

- `agent`: Override agent identity
- `body` (string, required): Comment text (markdown ok)
- `work_id` (string, required): Work item UUID

### `work_comment_list` (~38 tokens)

List comments on a work item (oldest first).

Input parameters:

- `limit` (integer)
- `work_id` (string, required): Work item UUID

### `project_create` (~99 tokens)

Create a project (Asana-style task container).

Input parameters:

- `agent`: Override agent identity
- `color`: Optional color label
- `default_view` (string): list, board, timeline, or calendar
- `description_md`: Optional markdown body
- `initiative_id`: Strategic initiative UUID for roll-up
- `name` (string, required): Project name
- `owner_email`: Owner member email
- `team_id`: Owning team UUID

### `project_list` (~53 tokens)

List projects in the org.

Input parameters:

- `include_archived` (boolean): Include archived projects
- `initiative_id`: Filter by initiative UUID
- `limit` (integer)
- `team_id`: Filter by team UUID

### `project_get` (~48 tokens)

Fetch a project with its sections, latest status, and optionally its tasks.

Input parameters:

- `include_items` (boolean): Include the project's tasks (board view)
- `project_id` (string, required): Project UUID

Output parameters:

- `result`

### `project_update` (~74 tokens)

Update project metadata.

Input parameters:

- `agent`: Override agent identity
- `color`: Color label
- `default_view`: list/board/timeline/calendar
- `description_md`: New markdown body
- `initiative_id`: Strategic initiative UUID
- `name`: New name
- `project_id` (string, required): Project UUID

Output parameters:

- `result`

### `project_archive` (~46 tokens)

Archive or restore a project.

Input parameters:

- `agent`: Override agent identity
- `archived` (boolean): True to archive, False to restore
- `project_id` (string, required): Project UUID

Output parameters:

- `result`

### `project_section_add` (~50 tokens)

Add an ordered section to a project.

Input parameters:

- `agent`: Override agent identity
- `name` (string, required): Section name (list group / board column)
- `project_id` (string, required): Project UUID

### `project_section_list` (~26 tokens)

List a project's sections in order.

Input parameters:

- `project_id` (string, required): Project UUID

### `project_status_post` (~79 tokens)

Post a project status update (on-track / at-risk / off-track banner).

Input parameters:

- `agent`: Override agent identity
- `body_md`: Status note (markdown ok)
- `project_id` (string, required): Project UUID
- `state_label`: on_track, at_risk, or off_track
- `status`: Alias for state_label

### `work_add_to_project` (~62 tokens)

Add a task to a project (tasks can belong to multiple projects).

Input parameters:

- `agent`: Override agent identity
- `project_id` (string, required): Project UUID
- `section_id`: Optional section UUID
- `work_id` (string, required): Work item UUID

### `work_remove_from_project` (~38 tokens)

Remove a task from a project.

Input parameters:

- `project_id` (string, required): Project UUID
- `work_id` (string, required): Work item UUID

### `work_move` (~73 tokens)

Move a task to a section and/or reorder it within a project.

Input parameters:

- `agent`: Override agent identity
- `project_id` (string, required): Project UUID
- `section_id`: Target section UUID
- `sort_order` (number): Fractional rank within section
- `work_id` (string, required): Work item UUID

Output parameters:

- `result`

### `work_subtasks_list` (~40 tokens)

List subtasks of a work item. Create subtasks via work_create with parent_id.

Input parameters:

- `work_id` (string, required): Parent work item UUID

### `work_dependency_add` (~115 tokens)

Add a dependency: blocker must finish before blocked can proceed.

Pass ``blocker_id`` + ``blocked_id``, or equivalently
\``work_id`` (blocked) + ``depends_on_id`` (blocker).

Input parameters:

- `agent`: Override agent identity
- `blocked_id`: Task that is blocked
- `blocker_id`: Task that must finish first
- `depends_on_id`: Alias for blocker_id (the task it waits on)
- `work_id`: Alias for blocked_id (the task that waits)

### `work_dependency_remove` (~66 tokens)

Remove a task dependency.

Input parameters:

- `blocked_id`: Blocked task UUID
- `blocker_id`: Blocker task UUID
- `depends_on_id`: Alias for blocker_id (the task it waits on)
- `work_id`: Alias for blocked_id (the task that waits)

### `work_dependencies_list` (~32 tokens)

List what a task is blocked by and what it blocks.

Input parameters:

- `work_id` (string, required): Work item UUID

### `work_follower_add` (~53 tokens)

Add a follower/collaborator to a task by member email.

Input parameters:

- `agent`: Override agent identity
- `follower_email`: Member email to add
- `work_id` (string, required): Work item UUID

### `work_follower_remove` (~41 tokens)

Remove a follower from a task by member email.

Input parameters:

- `follower_email`: Member email to remove
- `work_id` (string, required): Work item UUID

### `work_followers_list` (~31 tokens)

List followers/collaborators on a task.

Input parameters:

- `work_id` (string, required): Work item UUID

### `memory_graph_relate` (~138 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `object`: Alias for object_entity
- `object_entity`: Target entity
- `predicate` (string, required): Relationship label, e.g. 'works_on'
- `subject` (string, required): Source entity
- `weight` (number)

### `memory_graph_related` (~54 tokens)

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

Input parameters:

- `depth` (integer)
- `limit` (integer)
- `name` (string, required): Entity to expand neighbors of

### `memory_entity_view` (~41 tokens)

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

Input parameters:

- `slug` (string, required): Entity slug (wiki topic slug or ontology entity slug)

### `memory_ontology_list` (~26 tokens)

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

### `memory_ontology_propose_entity` (~79 tokens)

Propose a typed ontology entity (active immediately).

Input parameters:

- `agent`: Override agent identity
- `kind`: Alias for kind_name
- `kind_name`: Registered object kind, e.g. Person or Project
- `name` (string, required): Display name for the entity
- `properties`: Optional JSON properties matching the kind schema

### `memory_ontology_link_type_set` (~96 tokens)

Register or update a custom org link type.

Input parameters:

- `agent`: Override agent identity
- `cardinality` (string): one_to_many | many_to_many
- `description`: Human-readable description
- `from_kinds`: Allowed subject kinds (empty = any)
- `name` (string, required): Link predicate name, e.g. depends_on
- `to_kinds`: Allowed object kinds (empty = any)

### `memory_ontology_object_kind_set` (~63 tokens)

Register or update a custom org object kind.

Input parameters:

- `agent`: Override agent identity
- `description`: Human-readable description
- `name` (string, required): Object kind name, e.g. Vendor
- `properties_schema`: JSON schema for entity properties

### `memory_ontology_rekind_entity` (~65 tokens)

Change the object kind of an existing ontology entity.

Input parameters:

- `agent`: Override agent identity
- `kind`: Alias for kind_name
- `kind_name`: Registered object kind to assign, e.g. Person
- `slug` (string, required): Existing entity slug

### `memory_ontology_merge_entities` (~66 tokens)

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

Input parameters:

- `agent`: Override agent identity
- `drop_slug` (string, required): Duplicate entity slug to merge away
- `keep_slug` (string, required): Canonical entity slug to keep

### `memory_action_apply` (~66 tokens)

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

Input parameters:

- `action`: Alias for action_name
- `action_name`: Registered action type name, e.g. link_entities
- `agent`: Override agent identity
- `parameters` (object, required): Parameters matching the action schema

### `memory_action_log_list` (~26 tokens)

List recent governed action executions for the org.

Input parameters:

- `limit` (integer)

### `memory_forget` (~94 tokens)

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.

Input parameters:

- `memory_id` (string, required): memory_items UUID from a previous recall
- `reason` (string, required): Audit reason; required

### `memory_state_get` (~66 tokens)

Fetch JSON state scoped to the caller's org, bearer token, and ``repo``.

Input parameters:

- `key` (string, required): Opaque state key, e.g. continual-learning/index
- `repo` (string, required): Workspace slug (absolute path with leading / removed and / replaced by -)

### `memory_state_set` (~58 tokens)

Persist JSON state scoped to the caller's org, bearer token, and ``repo``.

Input parameters:

- `key` (string, required): Opaque state key
- `repo` (string, required): Workspace slug
- `value` (object, required): JSON object to store

### `integration_list` (~87 tokens)

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.

### `integration_search` (~138 tokens)

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.

Input parameters:

- `connector_id`: Specific connection id from integration_list; defaults to your own
- `k` (integer): Max results
- `kind` (string, required): Integration kind: 'gmail', 'slack', or 'discord'
- `query` (string, required): Search query (Gmail search syntax, Slack/Discord text filter)

### `integration_read` (~136 tokens)

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.

Input parameters:

- `connector_id`: Specific connection id from integration_list; defaults to your own
- `kind` (string, required): Integration kind: 'gmail', 'slack', or 'discord'
- `message_id` (string, required): Message id (Gmail) or 'channel:ts' (Slack) or 'channel_id:message_id' (Discord) to fetch

### `integration_send` (~190 tokens)

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.

Input parameters:

- `body` (string, required): Message body / text to send
- `channel`: Slack/Discord channel name/id; defaults to connector config
- `connector_id`: Specific connection id from integration_list; defaults to your own
- `kind` (string, required): Integration kind: 'gmail', 'slack', or 'discord'
- `subject`: Email subject (gmail only)
- `thread_id`: Gmail threadId to reply in (gmail only)
- `thread_ts`: Slack parent message ts, or Discord thread channel id, for a reply
- `to`: Recipient email (gmail only)

### `file_create` (~121 tokens)

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.

Input parameters:

- `agent`: Override agent identity
- `content` (string, required): File body (markdown or raw HTML)
- `content_format` (string): 'markdown' (rendered through the allowlist sanitizer) or 'html' (sanitized raw HTML)
- `title` (string, required): File title

### `file_upload_request` (~383 tokens)

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.

Input parameters:

- `agent`: Override agent identity
- `content_format` (string): 'html', 'markdown', or 'auto' (sniff from the file extension)
- `file_id`: Existing file UUID to append a new version to (update mode). Omit to create a new file.
- `filename`: Optional filename (used for format sniffing and as the script's default path)
- `publish` (boolean): If true, the file is published immediately (returns public URLs). In update mode this is idempotent if already published.
- `title` (string, required): File title (used only when creating a new file; ignored in update mode)
- `upload_base_url`: Optional server origin (e.g. https://teamshared.com). Defaults to settings.public_url.

### `file_update` (~109 tokens)

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.

Input parameters:

- `agent`: Override agent identity
- `content` (string, required): New file body (markdown or raw HTML)
- `content_format`: Override content format ('markdown' or 'html'); defaults to the file's current format
- `file_id` (string, required): File UUID to update

### `file_get` (~50 tokens)

Fetch a shared file with its latest version content.

Includes ``public_url`` (the ``/s/{slug}`` link) when the file is published.

Input parameters:

- `file_id` (string, required): File UUID

### `file_list` (~122 tokens)

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")``.

Input parameters:

- `limit` (integer)
- `query`: Optional case-insensitive title substring to filter by, e.g. 'yield vault'

### `file_publish` (~104 tokens)

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.

Input parameters:

- `file_id` (string, required): File UUID to publish

### `file_unpublish` (~65 tokens)

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.

Input parameters:

- `file_id` (string, required): File UUID to unpublish

### `file_archive` (~71 tokens)

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.

Input parameters:

- `file_id` (string, required): File UUID to archive

### `file_version_delete` (~137 tokens)

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

Input parameters:

- `file_id` (string, required): File UUID the version belongs to
- `version` (integer, required): Version number to delete

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/xhad-teamshared/teamshared#diagnostics

## Score history

- 2026-08-20: 64
- 2026-08-19: 64
- 2026-08-18: 36

## Links

- Remote endpoint: https://teamshared.com/mcp
- Repository: https://github.com/teamshared-ai/teamshared-plugin
- Website: https://teamshared.com/
- Changelog RSS feed: https://verifymcp.io/servers/xhad-teamshared/teamshared.xml
- Changelog JSON feed: https://verifymcp.io/servers/xhad-teamshared/teamshared.json
- HTML version of this page: https://verifymcp.io/servers/xhad-teamshared/teamshared