npm - coherence-mcp-server - Versions diffs - 0.5.0 → 0.5.2 - Mend

coherence-mcp-server 0.5.0 → 0.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +19 -3
package/README.template.md +5 -3
package/coherence_mcp_server/__init__.py +1 -1
package/coherence_mcp_server/server.py +606 -16
package/package.json +2 -2
package/pyproject.toml +1 -1
package/coherence_mcp_server/__pycache__/__init__.cpython-314.pyc +0 -0
package/coherence_mcp_server/__pycache__/server.cpython-314.pyc +0 -0

package/README.md CHANGED Viewed

@@ -1,8 +1,9 @@
+<!-- AUTO-GENERATED from README.template.md. Edit the template, not this file. -->
 # coherence-mcp-server
 **Give your AI agent native access to every idea, spec, contributor, and value chain in the Coherence Network.**
-An [MCP](https://modelcontextprotocol.io/) (Model Context Protocol) server that exposes the full Coherence Network API as 57 typed tools — so Claude, Cursor, Windsurf, or any MCP-compatible agent can browse ideas, look up specs, trace value lineage, link identities, record contributions, execute tasks, discover resonant peers, apply project blueprints, and read repository content via direct links without writing a single API call.
+An [MCP](https://modelcontextprotocol.io/) (Model Context Protocol) server that exposes the full Coherence Network API as 89 typed tools — so Claude, Cursor, Windsurf, or any MCP-compatible agent can browse ideas, look up specs, trace value lineage, link identities, record contributions, execute tasks, discover resonant peers, apply project blueprints, receive the shared agent invitation, and read repository content via direct links without writing a single API call.
 ```bash
 npx coherence-mcp-server
@@ -30,6 +31,7 @@ This MCP server changes that. It gives any agent a typed interface to:
 - **Direct Access** — read specs and documentation via direct repository links
 - **Ontology** — explore the Living Codex (184 universal concepts, 53 axes)
 - **Govern** — propose changes, vote on requests, and monitor network health
+- **Attune** — receive the shared AI-agent invitation before acting
 Every tool returns structured JSON. No parsing HTML. No scraping. Just clean data.
@@ -76,7 +78,7 @@ Point your MCP client at `npx coherence-mcp-server` via stdio transport.
 ---
-## Tools (57)
+## Tools (89)
 ### Ideas — the portfolio engine
@@ -125,6 +127,7 @@ Point your MCP client at `npx coherence-mcp-server` via stdio transport.
 | Tool | What it does |
 |------|-------------|
+| `coherence_agent_invitation` | Receive the shared AI-agent invitation: core frequency, attunement spectrum, entry surfaces, and contribution paths. |
 | `coherence_list_tasks` | See what tasks are pending, running, or failed. |
 | `coherence_get_task` | Full task details, direction, and result. |
 | `coherence_task_next` | Claim the highest-priority pending task. |
@@ -133,6 +136,19 @@ Point your MCP client at `npx coherence-mcp-server` via stdio transport.
 | `coherence_task_seed` | Create a new task from an idea. |
 | `coherence_task_events` | View the activity event log for a task. |
+### Awareness Streaming — presence in and out
+| Tool | What it does |
+|------|-------------|
+| `coherence_awareness_publish` | Publish a diagnostic awareness event from a node. |
+| `coherence_awareness_stream` | Read a bounded slice from diagnostic, node-message, or task SSE streams. |
+| `coherence_node_message_send` | Send a durable node-to-node or broadcast message. |
+| `coherence_node_messages` | Read durable inbound messages for a node. |
+Streams are intentionally bounded. `duration_seconds` defaults to 5 seconds
+and is capped at 30; `max_events` defaults to 20 and is capped at 200. This
+lets MCP clients sense live awareness without leaving a tool call open forever.
 ### Graph — universal navigation
 | Tool | What it does |
@@ -256,7 +272,7 @@ Every part of the network links to every other. Jump in wherever makes sense.
 | **Web** | Browse ideas, specs, and contributors visually | [coherencycoin.com](https://coherencycoin.com) |
 | **API** | 100+ endpoints, full OpenAPI docs, the engine behind everything | [api.coherencycoin.com/docs](https://api.coherencycoin.com/docs) |
 | **CLI** | Terminal-first access — `npm i -g coherence-cli` then `cc help` | [npm: coherence-cli](https://www.npmjs.com/package/coherence-cli) |
-| **MCP Server** | This package — 57 typed tools for AI agents | [npm: coherence-mcp-server](https://www.npmjs.com/package/coherence-mcp-server) |
+| **MCP Server** | This package — 89 typed tools for AI agents | [npm: coherence-mcp-server](https://www.npmjs.com/package/coherence-mcp-server) |
 | **OpenClaw Skill** | Auto-triggers in any OpenClaw instance for ideas, specs, coherence | [ClawHub: coherence-network](https://clawhub.com/skills/coherence-network) |
 | **GitHub** | Source code, specs, issues, and contribution tracking | [github.com/seeker71/Coherence-Network](https://github.com/seeker71/Coherence-Network) |

package/README.template.md CHANGED Viewed

@@ -2,7 +2,7 @@
 **Give your AI agent native access to every idea, spec, contributor, and value chain in the Coherence Network.**
-An [MCP](https://modelcontextprotocol.io/) (Model Context Protocol) server that exposes the full Coherence Network API as 57 typed tools — so Claude, Cursor, Windsurf, or any MCP-compatible agent can browse ideas, look up specs, trace value lineage, link identities, record contributions, execute tasks, discover resonant peers, apply project blueprints, and read repository content via direct links without writing a single API call.
+An [MCP](https://modelcontextprotocol.io/) (Model Context Protocol) server that exposes the full Coherence Network API as 89 typed tools — so Claude, Cursor, Windsurf, or any MCP-compatible agent can browse ideas, look up specs, trace value lineage, link identities, record contributions, execute tasks, discover resonant peers, apply project blueprints, receive the shared agent invitation, and read repository content via direct links without writing a single API call.
 ```bash
 npx coherence-mcp-server
@@ -30,6 +30,7 @@ This MCP server changes that. It gives any agent a typed interface to:
 - **Direct Access** — read specs and documentation via direct repository links
 - **Ontology** — explore the Living Codex (184 universal concepts, 53 axes)
 - **Govern** — propose changes, vote on requests, and monitor network health
+- **Attune** — receive the shared AI-agent invitation before acting
 Every tool returns structured JSON. No parsing HTML. No scraping. Just clean data.
@@ -76,7 +77,7 @@ Point your MCP client at `npx coherence-mcp-server` via stdio transport.
 ---
-## Tools (57)
+## Tools (89)
 ### Ideas — the portfolio engine
@@ -125,6 +126,7 @@ Point your MCP client at `npx coherence-mcp-server` via stdio transport.
 | Tool | What it does |
 |------|-------------|
+| `coherence_agent_invitation` | Receive the shared AI-agent invitation: core frequency, attunement spectrum, entry surfaces, and contribution paths. |
 | `coherence_list_tasks` | See what tasks are pending, running, or failed. |
 | `coherence_get_task` | Full task details, direction, and result. |
 | `coherence_task_next` | Claim the highest-priority pending task. |
@@ -256,7 +258,7 @@ Every part of the network links to every other. Jump in wherever makes sense.
 | **Web** | Browse ideas, specs, and contributors visually | [coherencycoin.com](https://coherencycoin.com) |
 | **API** | 100+ endpoints, full OpenAPI docs, the engine behind everything | [api.coherencycoin.com/docs](https://api.coherencycoin.com/docs) |
 | **CLI** | Terminal-first access — `npm i -g coherence-cli` then `cc help` | [npm: coherence-cli](https://www.npmjs.com/package/coherence-cli) |
-| **MCP Server** | This package — 57 typed tools for AI agents | [npm: coherence-mcp-server](https://www.npmjs.com/package/coherence-mcp-server) |
+| **MCP Server** | This package — 89 typed tools for AI agents | [npm: coherence-mcp-server](https://www.npmjs.com/package/coherence-mcp-server) |
 | **OpenClaw Skill** | Auto-triggers in any OpenClaw instance for ideas, specs, coherence | [ClawHub: coherence-network](https://clawhub.com/skills/coherence-network) |
 | **GitHub** | Source code, specs, issues, and contribution tracking | [github.com/seeker71/Coherence-Network](https://github.com/seeker71/Coherence-Network) |

package/coherence_mcp_server/__init__.py CHANGED Viewed

@@ -13,5 +13,5 @@ Environment variables:
     COHERENCE_API_KEY   API key for write operations (optional for reads)
 """
-__version__ = "0.3.1"
+__version__ = "0.5.2"
 __all__ = ["__version__"]

package/coherence_mcp_server/server.py CHANGED Viewed

@@ -1,6 +1,6 @@
 """Coherence Network MCP server — Python implementation.
-Exposes the Coherence Network API as 60 typed MCP tools.
+Exposes the Coherence Network API as typed MCP tools.
 """
 from __future__ import annotations
@@ -8,7 +8,9 @@ from __future__ import annotations
 import json
 import logging
 import os
+import time
 from typing import Any
+from urllib.parse import quote
 import httpx
 from mcp.server import Server
@@ -76,6 +78,112 @@ def api_patch(path: str, body: dict[str, Any]) -> Any:
         return {"error": str(exc)}
+def api_put(path: str, body: dict[str, Any]) -> Any:
+    url = f"{API_BASE}{path}"
+    try:
+        r = httpx.put(url, json=body, headers=_headers(), timeout=15.0)
+        r.raise_for_status()
+        return r.json()
+    except httpx.HTTPStatusError as exc:
+        try:
+            detail = exc.response.json().get("detail", exc.response.reason_phrase)
+        except Exception:
+            detail = exc.response.reason_phrase
+        return {"error": detail}
+    except Exception as exc:
+        return {"error": str(exc)}
+def decode_sse_events(lines: list[str]) -> list[dict[str, Any]]:
+    """Decode SSE data lines into JSON objects, preserving raw payloads."""
+    events: list[dict[str, Any]] = []
+    data_lines: list[str] = []
+    def flush() -> None:
+        if not data_lines:
+            return
+        payload = "\n".join(data_lines).strip()
+        data_lines.clear()
+        if not payload:
+            return
+        try:
+            parsed = json.loads(payload)
+            events.append(parsed if isinstance(parsed, dict) else {"data": parsed})
+        except json.JSONDecodeError:
+            events.append({"raw": payload})
+    for raw_line in lines:
+        line = raw_line.rstrip("\r\n")
+        if not line:
+            flush()
+            continue
+        if line.startswith(":"):
+            continue
+        if line.startswith("data:"):
+            data_lines.append(line[5:].lstrip())
+    flush()
+    return events
+def api_sse(
+    path: str,
+    params: dict[str, Any] | None = None,
+    *,
+    duration_seconds: float = 5.0,
+    max_events: int = 20,
+) -> dict[str, Any]:
+    """Read a bounded slice from an SSE endpoint and return parsed events."""
+    url = f"{API_BASE}{path}"
+    filtered = {k: v for k, v in (params or {}).items() if v is not None}
+    deadline = time.monotonic() + max(0.1, min(float(duration_seconds), 30.0))
+    read_timeout = max(1.0, min(float(duration_seconds) + 1.0, 10.0))
+    event_limit = max(1, min(int(max_events), 200))
+    lines: list[str] = []
+    events: list[dict[str, Any]] = []
+    try:
+        with httpx.stream(
+            "GET",
+            url,
+            params=filtered,
+            headers={**_headers(), "Accept": "text/event-stream"},
+            timeout=httpx.Timeout(connect=5.0, read=read_timeout, write=5.0, pool=5.0),
+        ) as response:
+            response.raise_for_status()
+            for line in response.iter_lines():
+                lines.append(line)
+                if line == "":
+                    events = decode_sse_events(lines)
+                    if len(events) >= event_limit:
+                        break
+                if time.monotonic() >= deadline:
+                    break
+        if not events:
+            events = decode_sse_events(lines)
+        events = events[:event_limit]
+        return {
+            "stream": path,
+            "duration_seconds": duration_seconds,
+            "max_events": event_limit,
+            "count": len(events),
+            "events": events,
+        }
+    except httpx.HTTPStatusError as exc:
+        return {"error": f"{exc.response.status_code} {exc.response.reason_phrase}", "stream": path}
+    except httpx.ReadTimeout:
+        events = decode_sse_events(lines)[:event_limit]
+        return {
+            "stream": path,
+            "duration_seconds": duration_seconds,
+            "max_events": event_limit,
+            "count": len(events),
+            "events": events,
+            "ended_by": "read_timeout",
+        }
+    except Exception as exc:
+        return {"error": str(exc), "stream": path}
 # ---------------------------------------------------------------------------
 # Tool definitions
 # ---------------------------------------------------------------------------
@@ -256,12 +364,75 @@ TOOLS: list[Tool] = [
             "properties": {"window_days": {"type": "number", "default": 30}},
         },
     ),
+    Tool(
+        name="coherence_agent_invitation",
+        description="Receive the shared AI-agent invitation: core frequency, attunement spectrum, entry surfaces, and contribution paths.",
+        inputSchema={"type": "object", "properties": {}},
+    ),
     # Federation
     Tool(
         name="coherence_list_federation_nodes",
         description="List federated nodes and their capabilities.",
         inputSchema={"type": "object", "properties": {}},
     ),
+    Tool(
+        name="coherence_awareness_publish",
+        description="Publish a diagnostic awareness event from a federation node. Delivered to active diagnostic stream subscribers.",
+        inputSchema={
+            "type": "object",
+            "required": ["node_id", "event_type"],
+            "properties": {
+                "node_id": {"type": "string", "description": "Publishing node ID"},
+                "event_type": {"type": "string", "description": "Awareness event kind, e.g. heartbeat, reasoning, tool_call"},
+                "message": {"type": "string", "description": "Short human-readable signal"},
+                "data": {"type": "object", "description": "Optional structured event payload"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_awareness_stream",
+        description="Read a bounded slice from diagnostic, node-message, or task-event SSE streams.",
+        inputSchema={
+            "type": "object",
+            "required": ["stream_type"],
+            "properties": {
+                "stream_type": {"type": "string", "description": "diagnostics, node, or task"},
+                "node_id": {"type": "string", "description": "Node ID for diagnostics/node streams; use '*' for all diagnostics"},
+                "task_id": {"type": "string", "description": "Task ID for task event streams"},
+                "duration_seconds": {"type": "number", "description": "Max seconds to hold stream open (default 5, max 30)", "default": 5},
+                "max_events": {"type": "number", "description": "Max parsed events to return (default 20, max 200)", "default": 20},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_node_message_send",
+        description="Send a federation node message. Use to stream awareness out as durable node-to-node text or command payloads.",
+        inputSchema={
+            "type": "object",
+            "required": ["from_node_id", "text"],
+            "properties": {
+                "from_node_id": {"type": "string", "description": "Sender node ID"},
+                "to_node_id": {"type": "string", "description": "Recipient node ID; omit for broadcast"},
+                "type": {"type": "string", "description": "Message type, e.g. text, command, command_response", "default": "text"},
+                "text": {"type": "string", "description": "Message text"},
+                "payload": {"type": "object", "description": "Optional structured payload"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_node_messages",
+        description="Read federation node messages for a node. This is the durable inbound awareness channel.",
+        inputSchema={
+            "type": "object",
+            "required": ["node_id"],
+            "properties": {
+                "node_id": {"type": "string", "description": "Recipient node ID"},
+                "since": {"type": "string", "description": "Optional ISO timestamp lower bound"},
+                "unread_only": {"type": "boolean", "description": "Only unread messages (default true)", "default": True},
+                "limit": {"type": "number", "description": "Max messages to return (default 50)", "default": 50},
+            },
+        },
+    ),
     # Tasks (Agent Work Protocol)
     Tool(
         name="coherence_list_tasks",
@@ -273,6 +444,7 @@ TOOLS: list[Tool] = [
                 "task_type": {"type": "string", "description": "Filter by type: spec, test, impl, review, code-review"},
                 "limit": {"type": "number", "description": "Max tasks to return (default 20)", "default": 20},
                 "offset": {"type": "number", "description": "Pagination offset", "default": 0},
+                "workspace_id": {"type": "string", "description": "Optional workspace to filter by (via each task's linked idea)."},
             },
         },
     ),
@@ -294,6 +466,7 @@ TOOLS: list[Tool] = [
             "type": "object",
             "properties": {
                 "worker_id": {"type": "string", "description": "Identity of the agent/node claiming the task (defaults to 'mcp-agent')"},
+                "workspace_id": {"type": "string", "description": "Optional workspace to filter pending tasks by."},
             },
         },
     ),
@@ -306,6 +479,7 @@ TOOLS: list[Tool] = [
             "properties": {
                 "task_id": {"type": "string", "description": "The task ID"},
                 "worker_id": {"type": "string", "description": "Identity of the agent/node (defaults to 'mcp-agent')"},
+                "workspace_id": {"type": "string", "description": "Optional workspace context for the claim."},
             },
         },
     ),
@@ -332,6 +506,7 @@ TOOLS: list[Tool] = [
                 "idea_id": {"type": "string", "description": "Target idea ID"},
                 "task_type": {"type": "string", "description": "Type of task: spec, test, impl, review (default: spec)", "default": "spec"},
                 "direction": {"type": "string", "description": "Optional custom instruction for the task"},
+                "workspace_id": {"type": "string", "description": "Optional workspace to scope this task to."},
             },
         },
     ),
@@ -714,7 +889,7 @@ TOOLS: list[Tool] = [
             "type": "object",
             "required": ["path"],
             "properties": {
-                "path": {"type": "string", "description": "Relative path from repo root (e.g. 'specs/169-procedural-memory.md')"},
+                "path": {"type": "string", "description": "Relative path from repo root (e.g. 'specs/smart-reap.md')"},
             },
         },
     ),
@@ -822,6 +997,235 @@ TOOLS: list[Tool] = [
             },
         },
     ),
+    # Pipeline Policies
+    Tool(
+        name="coherence_pipeline_policies",
+        description="View or update pipeline policies (phase_chain, max_retries, failure_patterns, provider_per_phase, etc). Use action='list' to see all, action='get' with key, action='set' with key+value.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "action": {"type": "string", "enum": ["list", "get", "set"], "description": "Operation to perform"},
+                "key": {"type": "string", "description": "Policy key (for get/set)"},
+                "value": {"description": "Policy value to set (any JSON type, for set action)"},
+            },
+            "required": ["action"],
+        },
+    ),
+    # Workspace Tasks
+    Tool(
+        name="coherence_workspace_tasks",
+        description="List tasks for a specific workspace, seed a full pipeline (spec->impl->test->review->deploy->verify), or get workspace status.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace ID to scope operations to"},
+                "action": {"type": "string", "enum": ["list", "seed_pipeline", "status"], "description": "Action to perform"},
+                "idea_id": {"type": "string", "description": "Idea ID (for seed_pipeline action)"},
+                "start_phase": {"type": "string", "description": "Starting phase (default: spec)", "default": "spec"},
+            },
+            "required": ["workspace_id", "action"],
+        },
+    ),
+    # Team Membership
+    Tool(
+        name="coherence_list_workspace_members",
+        description="List members of a workspace with their roles and join dates.",
+        inputSchema={
+            "type": "object",
+            "required": ["workspace_id"],
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace slug"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_invite_member",
+        description="Invite a contributor to a workspace with an optional role.",
+        inputSchema={
+            "type": "object",
+            "required": ["workspace_id", "contributor_id"],
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace slug"},
+                "contributor_id": {"type": "string", "description": "Contributor to invite"},
+                "role": {"type": "string", "description": "Role: owner, admin, member (default: member)", "default": "member"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_list_my_workspaces",
+        description="List workspaces that a contributor belongs to.",
+        inputSchema={
+            "type": "object",
+            "required": ["contributor_id"],
+            "properties": {
+                "contributor_id": {"type": "string", "description": "Contributor ID"},
+            },
+        },
+    ),
+    # Messaging
+    Tool(
+        name="coherence_send_message",
+        description="Send a message to a contributor (DM) or a workspace channel.",
+        inputSchema={
+            "type": "object",
+            "required": ["from_contributor_id", "body"],
+            "properties": {
+                "from_contributor_id": {"type": "string", "description": "Sender contributor ID"},
+                "to_contributor_id": {"type": "string", "description": "Recipient contributor ID (for DM)"},
+                "to_workspace_id": {"type": "string", "description": "Target workspace ID (for workspace message)"},
+                "subject": {"type": "string", "description": "Optional message subject"},
+                "body": {"type": "string", "description": "Message body text"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_get_inbox",
+        description="Get inbox messages for a contributor with optional filters.",
+        inputSchema={
+            "type": "object",
+            "required": ["contributor_id"],
+            "properties": {
+                "contributor_id": {"type": "string", "description": "Contributor ID"},
+                "limit": {"type": "number", "description": "Max messages to return (default 20)", "default": 20},
+                "unread_only": {"type": "boolean", "description": "Only return unread messages", "default": False},
+            },
+        },
+    ),
+    # Activity
+    Tool(
+        name="coherence_get_workspace_activity",
+        description="Get the activity feed (event timeline) for a workspace.",
+        inputSchema={
+            "type": "object",
+            "required": ["workspace_id"],
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace slug"},
+                "limit": {"type": "number", "description": "Max events to return (default 20)", "default": 20},
+            },
+        },
+    ),
+    # Projects
+    Tool(
+        name="coherence_list_workspace_projects",
+        description="List projects in a workspace for organizing ideas into groups.",
+        inputSchema={
+            "type": "object",
+            "required": ["workspace_id"],
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace slug"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_create_workspace_project",
+        description="Create a new project within a workspace to group related ideas.",
+        inputSchema={
+            "type": "object",
+            "required": ["workspace_id", "name"],
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace slug"},
+                "name": {"type": "string", "description": "Project name"},
+                "description": {"type": "string", "description": "Project description"},
+            },
+        },
+    ),
+    # ── Discovery / Living Network ──
+    Tool(
+        name="coherence_discover",
+        description="Serendipity feed — personalized discovery of resonant ideas, peers, cross-domain connections, and news. Returns what resonates with who you are.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "contributor_id": {"type": "string", "description": "Contributor to discover for (default: general feed)"},
+                "limit": {"type": "integer", "description": "Max items (default 20)"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_constellation",
+        description="Network visualization data — nodes (ideas, contributors, concepts) and edges with positions for galaxy/constellation rendering.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "max_nodes": {"type": "integer", "description": "Max nodes to return (default 80)"},
+                "workspace_id": {"type": "string", "description": "Workspace to visualize (default: coherence-network)"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_vitality",
+        description="Workspace health as living-system signals — diversity index, resonance density, flow rate, breath rhythm, connection strength, activity pulse.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "workspace_id": {"type": "string", "description": "Workspace ID (default: coherence-network)"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_resonate",
+        description="Find ideas that share deep structural patterns with a given idea — cross-domain resonance via harmonic matching.",
+        inputSchema={
+            "type": "object",
+            "required": ["idea_id"],
+            "properties": {
+                "idea_id": {"type": "string", "description": "Idea to find resonances for"},
+                "limit": {"type": "integer", "description": "Max matches (default 10)"},
+            },
+        },
+    ),
+    # ── Super-Idea Coverage: News, Federation, Beliefs, CC, Governance ──
+    Tool(
+        name="coherence_news_feed",
+        description="Get the latest news items from configured RSS sources.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "limit": {"type": "number", "description": "Max items to return (default 20)", "default": 20},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_news_resonance",
+        description="Get news items matched to ideas with resonance scores.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "top_n": {"type": "number", "description": "Top N matches (default 5)", "default": 5},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_federation_nodes",
+        description="List federation nodes with hostname, OS, providers, and last heartbeat.",
+        inputSchema={"type": "object", "properties": {}},
+    ),
+    Tool(
+        name="coherence_belief_profile",
+        description="Get the belief profile for a contributor — worldview axes and top concepts.",
+        inputSchema={
+            "type": "object",
+            "required": ["contributor_id"],
+            "properties": {
+                "contributor_id": {"type": "string", "description": "Contributor ID"},
+            },
+        },
+    ),
+    Tool(
+        name="coherence_cc_supply",
+        description="Get CC token economics — total minted, outstanding, and coherence score.",
+        inputSchema={"type": "object", "properties": {}},
+    ),
+    Tool(
+        name="coherence_governance_requests",
+        description="List governance change requests with status and proposer info.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "limit": {"type": "number", "description": "Max requests to return (default 20)", "default": 20},
+            },
+        },
+    ),
 ]
 TOOL_MAP: dict[str, Tool] = {t.name: t for t in TOOLS}
@@ -880,10 +1284,8 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
                 "display_name": args["provider_id"],
             })
         case "coherence_lookup_identity":
-            from urllib.parse import quote
             return api_get(f"/api/identity/lookup/{quote(args['provider'])}/{quote(args['provider_id'])}")
         case "coherence_get_identities":
-            from urllib.parse import quote
             return api_get(f"/api/identity/{quote(args['contributor_id'])}")
         # Contributions
         case "coherence_record_contribution":
@@ -898,7 +1300,6 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
                 }.items() if v is not None
             })
         case "coherence_contributor_ledger":
-            from urllib.parse import quote
             return api_get(f"/api/contributions/ledger/{quote(args['contributor_id'])}")
         # Status
         case "coherence_status":
@@ -912,24 +1313,84 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
             }
         case "coherence_friction_report":
             return api_get("/api/friction/report", {"window_days": args.get("window_days", 30)})
+        case "coherence_agent_invitation":
+            return api_get("/api/agent/invitation")
         # Federation
         case "coherence_list_federation_nodes":
             nodes = api_get("/api/federation/nodes")
             caps = api_get("/api/federation/nodes/capabilities")
             return {"nodes": nodes, "capabilities": caps}
+        case "coherence_awareness_publish":
+            body = {
+                "event_type": args["event_type"],
+                "message": args.get("message", ""),
+                "data": args.get("data", {}),
+                "source": "mcp",
+            }
+            return api_post(f"/api/federation/nodes/{quote(args['node_id'], safe='')}/diag", body)
+        case "coherence_awareness_stream":
+            stream_type = (args.get("stream_type") or "").strip().lower()
+            duration_seconds = args.get("duration_seconds", 5)
+            max_events = args.get("max_events", 20)
+            if stream_type == "diagnostics":
+                node_id = args.get("node_id") or "*"
+                return api_sse(
+                    f"/api/federation/nodes/{quote(node_id, safe='*')}/diag/stream",
+                    duration_seconds=duration_seconds,
+                    max_events=max_events,
+                )
+            if stream_type == "node":
+                node_id = args.get("node_id")
+                if not node_id:
+                    return {"error": "node_id is required for node streams"}
+                return api_sse(
+                    f"/api/federation/nodes/{quote(node_id, safe='')}/stream",
+                    duration_seconds=duration_seconds,
+                    max_events=max_events,
+                )
+            if stream_type == "task":
+                task_id = args.get("task_id")
+                if not task_id:
+                    return {"error": "task_id is required for task streams"}
+                return api_sse(
+                    f"/api/agent/tasks/{quote(task_id, safe='')}/events",
+                    duration_seconds=duration_seconds,
+                    max_events=max_events,
+                )
+            return {"error": "stream_type must be one of: diagnostics, node, task"}
+        case "coherence_node_message_send":
+            body = {
+                "to_node": args.get("to_node_id"),
+                "type": args.get("type", "text"),
+                "text": args["text"],
+                "payload": args.get("payload", {}),
+            }
+            return api_post(f"/api/federation/nodes/{quote(args['from_node_id'], safe='')}/messages", body)
+        case "coherence_node_messages":
+            return api_get(f"/api/federation/nodes/{quote(args['node_id'], safe='')}/messages", {
+                "since": args.get("since"),
+                "unread_only": args.get("unread_only", True),
+                "limit": args.get("limit", 50),
+            })
         # Tasks
         case "coherence_list_tasks":
-            return api_get("/api/agent/tasks", {
+            params = {
                 "status": args.get("status"),
                 "task_type": args.get("task_type"),
                 "limit": args.get("limit", 20),
                 "offset": args.get("offset", 0),
-            })
+            }
+            if args.get("workspace_id"):
+                params["workspace_id"] = args["workspace_id"]
+            return api_get("/api/agent/tasks", params)
         case "coherence_get_task":
             return api_get(f"/api/agent/tasks/{args['task_id']}")
         case "coherence_task_next":
             # Claim next available pending task
-            data = api_get("/api/agent/tasks", {"status": "pending", "limit": 1})
+            params: dict[str, Any] = {"status": "pending", "limit": 1}
+            if args.get("workspace_id"):
+                params["workspace_id"] = args["workspace_id"]
+            data = api_get("/api/agent/tasks", params)
             tasks = data.get("tasks", []) if isinstance(data, dict) else []
             if not tasks:
                 return {"error": "No pending tasks available"}
@@ -955,14 +1416,17 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
             idea_name = idea.get("name", "Unknown Idea") if isinstance(idea, dict) else "Unknown Idea"
             task_type = args.get("task_type", "spec")
             direction = args.get("direction") or f"{task_type} for '{idea_name}' ({idea_id})"
+            context: dict[str, Any] = {
+                "idea_id": idea_id,
+                "idea_name": idea_name,
+                "seeded_by": "mcp-agent",
+            }
+            if args.get("workspace_id"):
+                context["workspace_id"] = args["workspace_id"]
             return api_post("/api/agent/tasks", {
                 "task_type": task_type,
                 "direction": direction,
-                "context": {
-                    "idea_id": idea_id,
-                    "idea_name": idea_name,
-                    "seeded_by": "mcp-agent",
-                },
+                "context": context,
             })
         case "coherence_task_events":
             return api_get(f"/api/agent/tasks/{args['task_id']}/stream")
@@ -1226,7 +1690,7 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
                         "navigation": {"idea_file": f"ideas/{entity_id}.md",
                                        "spec_files": [f"specs/{s}.md" for s in spec_ids],
                                        "api": f"/api/ideas/{entity_id}",
-                                       "cli": f"cc idea {entity_id}"}}
+                                       "cli": f"coh idea {entity_id}"}}
             elif entity_type == "spec":
                 spec = api_get(f"/api/spec-registry/{entity_id}")
                 spec_file = api_get("/api/content/file", {"path": f"specs/{entity_id}.md"})
@@ -1234,7 +1698,7 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
                 parent_idea = api_get(f"/api/ideas/{idea_id}") if idea_id else None
                 nav: dict[str, Any] = {"spec_file": f"specs/{entity_id}.md",
                                        "api": f"/api/spec-registry/{entity_id}",
-                                       "cli": f"cc spec {entity_id}"}
+                                       "cli": f"coh spec {entity_id}"}
                 if idea_id:
                     nav["idea_file"] = f"ideas/{idea_id}.md"
                 return {"entity_type": "spec", "spec": spec, "spec_file_content": spec_file,
@@ -1248,9 +1712,135 @@ def dispatch(name: str, args: dict[str, Any]) -> Any:
                 return {"entity_type": "task", "task": task, "events": events,
                         "parent_idea": parent_idea,
                         "navigation": {"api": f"/api/agent/tasks/{entity_id}",
-                                       "cli": f"cc task {entity_id}"}}
+                                       "cli": f"coh task {entity_id}"}}
             else:
                 return {"error": f"Unknown entity_type: {entity_type}. Use 'idea', 'spec', or 'task'."}
+        # Pipeline Policies
+        case "coherence_pipeline_policies":
+            action = (args.get("action") or "list").strip()
+            if action == "list":
+                return api_get("/api/pipeline/policies")
+            elif action == "get":
+                key = args.get("key", "")
+                return api_get(f"/api/pipeline/policies/{key}")
+            elif action == "set":
+                key = args.get("key", "")
+                value = args.get("value")
+                return api_put(f"/api/pipeline/policies/{key}", {
+                    "value": value,
+                    "updated_by": "mcp-agent",
+                })
+            else:
+                return {"error": f"Unknown action: {action}. Use 'list', 'get', or 'set'."}
+        # Workspace Tasks
+        case "coherence_workspace_tasks":
+            ws_id = args["workspace_id"]
+            action = args["action"]
+            if action == "list":
+                return api_get(f"/api/agent/tasks", {"workspace_id": ws_id, "limit": 50})
+            elif action == "seed_pipeline":
+                idea_id = args.get("idea_id", "")
+                start_phase = args.get("start_phase", "spec")
+                return api_post("/api/agent/tasks", {
+                    "direction": f"Implement idea {idea_id} starting from {start_phase} phase",
+                    "task_type": start_phase,
+                    "context": {
+                        "idea_id": idea_id,
+                        "workspace_id": ws_id,
+                        "executor": "federation",
+                    },
+                })
+            elif action == "status":
+                tasks_data = api_get(f"/api/agent/tasks", {"workspace_id": ws_id, "limit": 200})
+                items = (
+                    tasks_data.get("items", [])
+                    if isinstance(tasks_data, dict)
+                    else tasks_data if isinstance(tasks_data, list)
+                    else []
+                )
+                status_counts: dict[str, int] = {}
+                for t in items:
+                    s = t.get("status", "unknown") if isinstance(t, dict) else "unknown"
+                    status_counts[s] = status_counts.get(s, 0) + 1
+                return {
+                    "workspace_id": ws_id,
+                    "total_tasks": len(items),
+                    "by_status": status_counts,
+                }
+            else:
+                return {"error": f"Unknown action: {action}. Use 'list', 'seed_pipeline', or 'status'."}
+        # Team Membership
+        case "coherence_list_workspace_members":
+            return api_get(f"/api/workspaces/{args['workspace_id']}/members")
+        case "coherence_invite_member":
+            return api_post(f"/api/workspaces/{args['workspace_id']}/invite", {
+                "contributor_id": args["contributor_id"],
+                "role": args.get("role", "member"),
+            })
+        case "coherence_list_my_workspaces":
+            return api_get(f"/api/contributors/{args['contributor_id']}/workspaces")
+        # Messaging
+        case "coherence_send_message":
+            body: dict[str, Any] = {
+                "from_contributor_id": args["from_contributor_id"],
+                "body": args["body"],
+            }
+            if args.get("to_contributor_id"):
+                body["to_contributor_id"] = args["to_contributor_id"]
+            if args.get("to_workspace_id"):
+                body["to_workspace_id"] = args["to_workspace_id"]
+            if args.get("subject"):
+                body["subject"] = args["subject"]
+            return api_post("/api/messages", body)
+        case "coherence_get_inbox":
+            return api_get(f"/api/messages/inbox/{args['contributor_id']}", {
+                "limit": args.get("limit", 20),
+                "unread_only": args.get("unread_only", False),
+            })
+        # Activity
+        case "coherence_get_workspace_activity":
+            return api_get(f"/api/workspaces/{args['workspace_id']}/activity", {
+                "limit": args.get("limit", 20),
+            })
+        # Projects
+        case "coherence_list_workspace_projects":
+            return api_get(f"/api/workspaces/{args['workspace_id']}/projects")
+        case "coherence_create_workspace_project":
+            return api_post(f"/api/workspaces/{args['workspace_id']}/projects", {
+                "name": args["name"],
+                "description": args.get("description", ""),
+                "workspace_id": args["workspace_id"],
+            })
+        # Discovery / Living Network
+        case "coherence_discover":
+            cid = args.get("contributor_id", "default-contributor")
+            limit: int = args.get("limit", 20)
+            return api_get(f"/api/discover/{cid}", {"limit": limit})
+        case "coherence_constellation":
+            return api_get("/api/constellation", {
+                "max_nodes": args.get("max_nodes", 80),
+                "workspace_id": args.get("workspace_id", "coherence-network"),
+            })
+        case "coherence_vitality":
+            ws = args.get("workspace_id", "coherence-network")
+            return api_get(f"/api/workspaces/{ws}/vitality")
+        case "coherence_resonate":
+            return api_get(f"/api/resonance/ideas/{args['idea_id']}", {
+                "limit": args.get("limit", 10),
+            })
+        # Super-Idea Coverage
+        case "coherence_news_feed":
+            return api_get("/api/news/feed", {"limit": args.get("limit", 20)})
+        case "coherence_news_resonance":
+            return api_get("/api/news/resonance", {"top_n": args.get("top_n", 5)})
+        case "coherence_federation_nodes":
+            return api_get("/api/federation/nodes")
+        case "coherence_belief_profile":
+            return api_get(f"/api/beliefs/{args['contributor_id']}")
+        case "coherence_cc_supply":
+            return api_get("/api/cc/supply")
+        case "coherence_governance_requests":
+            return api_get("/api/governance/change-requests", {"limit": args.get("limit", 20)})
         case _:
             return {"error": f"Unknown tool: {name}"}

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "coherence-mcp-server",
-  "version": "0.5.0",
-  "description": "Unified MCP server for the Coherence Network — 51 typed tools for AI agents to browse ideas, manage tasks, link identities, and navigate the universal graph.",
+  "version": "0.5.2",
+  "description": "Unified MCP server for the Coherence Network — 89 typed tools for AI agents to browse ideas, receive the shared invitation, manage tasks, link identities, and navigate the universal graph.",
   "type": "module",
   "bin": {
     "coherence-mcp-server": "index.mjs"

package/pyproject.toml CHANGED Viewed

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "coherence-mcp-server"
-version = "0.4.0"
+version = "0.5.2"
 description = "Unified MCP server for the Coherence Network — 51 typed tools for AI agents to browse ideas, manage tasks, link identities, and navigate the universal graph."
 readme = "README.md"
 requires-python = ">=3.10"

package/coherence_mcp_server/__pycache__/__init__.cpython-314.pyc DELETED Viewed

Binary file

package/coherence_mcp_server/__pycache__/server.cpython-314.pyc DELETED Viewed

Binary file