@ouro.bot/friends 0.1.0-alpha.4

package/dist/mcp/schemas.js

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolSchemas = getToolSchemas;
+// MCP tool schemas for the friends server.
+//
+// 29 tools — a thin 1:1 surface over the friends library (D7): the original 14,
+// the cross-agent moat surface (resolve_room, import_profile, grant_share,
+// revoke_share, list_shares; share_profile is de-stubbed in place), the brick-3
+// mission ledger (record_mission, get_mission, list_missions, share_mission,
+// import_mission), the brick-4 earned-standing lenses (assess_standing,
+// explain_standing — read-only, advisory; never write trust, never on the wire),
+// and the brick-5 coordination verbs (coordinate, import_coordination,
+// get_coordination — negotiate WHO does a mission; advisory assignment metadata).
+// Each schema follows JSON Schema for
+// `inputSchema` as required by MCP. The shape mirrors the harness's McpToolSchema
+// so the same client tooling consumes both.
+const observability_1 = require("../observability");
+const STRING = { type: "string" };
+function getToolSchemas() {
+    (0, observability_1.emitNervesEvent)({
+        component: "clients",
+        event: "clients.mcp_tool_schemas",
+        message: "listed friends mcp tool schemas",
+        meta: {},
+    });
+    return [
+        {
+            name: "resolve_party",
+            description: "Resolve an external identity (provider + externalId on a channel) into a friend record, creating one on first contact. Returns { friend, channel, created }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    provider: { type: "string", description: "identity provider, e.g. aad, local, teams-conversation, imessage-handle, email-address, a2a-agent" },
+                    externalId: { type: "string", description: "the external identity within the provider" },
+                    displayName: { type: "string", description: "display name for the party (use 'Unknown' if not known)" },
+                    channel: { type: "string", description: "the channel/sense the session belongs to, e.g. cli, teams, mcp" },
+                    tenantId: { type: "string", description: "optional tenant id" },
+                },
+                required: ["provider", "externalId"],
+            },
+        },
+        {
+            name: "describe_trust",
+            description: "Explain the trust context for a friend: level, basis (direct/shared_group/unknown), what it permits and constrains.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                    channel: { type: "string", description: "the channel/sense for the explanation" },
+                    isGroupChat: { type: "string", description: "set to 'true' when the conversation is a group chat" },
+                },
+                required: ["friendId", "channel"],
+            },
+        },
+        {
+            name: "assess_standing",
+            description: "Assess a peer's earned standing from your FIRST-PARTY outcomes with them: a tier (proven/reliable/mixed/untested/troubled), the basis count, and the tally. Advisory only — never changes trust, never shared. Returns a Standing, or { ok:false, status:'not_found' } when the friend is missing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                },
+                required: ["friendId"],
+            },
+        },
+        {
+            name: "explain_standing",
+            description: "Explain a peer's earned standing in words: the tier with a human summary, why, and advisory notes that frame it as input to a MANUAL trust decision (never an instruction to change trust). Returns a StandingExplanation, or { ok:false, status:'not_found' } when the friend is missing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                },
+                required: ["friendId"],
+            },
+        },
+        {
+            name: "get_friend",
+            description: "Fetch a single friend record by uuid or by name.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                },
+                required: ["friendId"],
+            },
+        },
+        {
+            name: "list_friends",
+            description: "List friend records, optionally filtered by trust level and kind, optionally limited.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    trust: { type: "string", description: "filter by trust level: family/friend/acquaintance/stranger" },
+                    kind: { type: "string", description: "filter by kind: human/agent" },
+                    limit: { type: "string", description: "max number of records to return" },
+                },
+            },
+        },
+        {
+            name: "save_note",
+            description: "Save a friend's name, a tool preference, or a general note. Use override='true' to overwrite an existing value.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                    type: { type: "string", enum: ["name", "tool_preference", "note"], description: "what to save" },
+                    key: { type: "string", description: "key for tool_preference or note" },
+                    content: { type: "string", description: "the value to save" },
+                    override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
+                    provenance: { type: "object", description: "optional attribution { assertedBy: { agentId, agentName } }" },
+                },
+                required: ["friendId", "type", "content"],
+            },
+        },
+        {
+            name: "record_interaction",
+            description: "Record a turn with a friend: accumulate token usage and/or append a shared-mission outcome (bumping familiarity).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                    usage: { type: "object", description: "token usage; only output_tokens is counted" },
+                    outcome: { type: "object", description: "shared-mission outcome { missionId, result, note? }" },
+                    familiarityDelta: { type: "string", description: "how much to bump familiarity (default 1)" },
+                    provenance: { type: "object", description: "optional attribution for the outcome" },
+                },
+                required: ["friendId"],
+            },
+        },
+        {
+            name: "upsert_group",
+            description: "Upsert shared-group participant context: link each participant to the group, promoting strangers to acquaintances.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    groupExternalId: { type: "string", description: "the group's external id" },
+                    participants: { type: "array", description: "participants [{ provider, externalId, displayName? }]" },
+                },
+                required: ["groupExternalId", "participants"],
+            },
+        },
+        {
+            name: "set_trust",
+            description: "Set a friend's trust level (also mirrors it onto the record's role).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                    trustLevel: { type: "string", enum: ["family", "friend", "acquaintance", "stranger"], description: "the trust level to set" },
+                },
+                required: ["friendId", "trustLevel"],
+            },
+        },
+        {
+            name: "link_identity",
+            description: "Link an external identity to a friend, merging any orphan record that already holds it (cross-channel unification).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                    provider: STRING,
+                    externalId: STRING,
+                    tenantId: { type: "string", description: "optional tenant id" },
+                },
+                required: ["friendId", "provider", "externalId"],
+            },
+        },
+        {
+            name: "unlink_identity",
+            description: "Remove an external identity from a friend.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "friend uuid or name" },
+                    provider: STRING,
+                    externalId: STRING,
+                },
+                required: ["friendId", "provider", "externalId"],
+            },
+        },
+        {
+            name: "onboard_agent",
+            description: "Upsert an agent-peer friend record from already-resolved coordinates (no HTTP card fetch).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "the peer agent's name" },
+                    agentId: { type: "string", description: "the a2a agent id" },
+                    trustLevel: { type: "string", description: "trust level (default acquaintance)" },
+                    a2a: { type: "object", description: "a2a coordinates { cardUrl?, endpointUrl?, protocolVersion? }" },
+                    mailbox: { type: "object", description: "optional A2A git-mailbox coords { repo, selfOutboxAgentId }" },
+                    bundleName: { type: "string", description: "optional bundle name" },
+                },
+                required: ["name", "agentId"],
+            },
+        },
+        {
+            name: "whoami",
+            description: "Resolve who the machine owner is and which friend record represents the self.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "channel_caps",
+            description: "Return the capabilities of a channel (integrations, markdown, streaming, rich cards, max length).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    channel: { type: "string", description: "the channel to look up" },
+                },
+                required: ["channel"],
+            },
+        },
+        {
+            name: "resolve_room",
+            description: "Resolve a room (a group's external id) into its members, each with their trust context and how they're known (direct/group_only). Pure read.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    groupExternalId: { type: "string", description: "the group's external id (e.g. group:project;+;g1)" },
+                    channel: { type: "string", description: "channel lens for the trust explanation (default mcp)" },
+                },
+                required: ["groupExternalId"],
+            },
+        },
+        {
+            name: "share_profile",
+            description: "Producer: prepare a consent-gated, scope-filtered, provenance-preserving profile-share envelope for another agent (names the party by join key, never the local uuid). Self identity comes from whoami. Returns { ok, envelope } or { ok:false, status }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    friendId: { type: "string", description: "the local friend to share (uuid or name)" },
+                    toAgentId: { type: "string", description: "the recipient agent's join-key agentId" },
+                    scope: { type: "string", enum: ["name", "identity", "notes:safe", "notes:all", "outcomes"], description: "what to share: identity scopes carry only the join key; notes:* / outcomes require an explicit grant under the default tiered policy" },
+                    proof: { type: "string", description: "optional opaque proof to stamp on the envelope (for a non-TOFU recipient verifier)" },
+                },
+                required: ["friendId", "toAgentId", "scope"],
+            },
+        },
+        {
+            name: "import_profile",
+            description: "Consumer (non-clobbering merge): import a profile-share envelope. Resolves the party by join key; lands facts in the imported namespace WITHOUT touching first-party notes; source trust caps acceptance; never changes the party's trust. Returns { ok, status, record }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    envelope: { type: "object", description: "the ProfileShareEnvelope to import" },
+                    fromAgentId: { type: "string", description: "the agent the envelope arrived from (join-key agentId)" },
+                    trustOfSource: { type: "string", enum: ["family", "friend", "acquaintance", "stranger"], description: "this agent's resolved trust in the source agent — the acceptance cap" },
+                },
+                required: ["envelope", "fromAgentId", "trustOfSource"],
+            },
+        },
+        {
+            name: "grant_share",
+            description: "Mint an explicit, revocable consent grant: an agent may receive a scope of a subject (a friend's profile, keyed by friend uuid; or a mission, keyed by its missionKey). The consent half of the moat.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    subjectKey: { type: "string", description: "whose data may be shared — a local friend uuid for a profile, or a missionKey for a mission (the legacy arg name subjectFriendId is still accepted)" },
+                    recipientAgentId: { type: "string", description: "the agent that may receive it (join-key agentId)" },
+                    scope: { type: "string", enum: ["name", "identity", "notes:safe", "notes:all", "outcomes", "mission"], description: "the scope consented to" },
+                    expiresAt: { type: "string", description: "optional ISO expiry; absent ⇒ never expires" },
+                },
+                required: ["subjectKey", "recipientAgentId", "scope"],
+            },
+        },
+        {
+            name: "revoke_share",
+            description: "Revoke a consent grant by id (tombstones it; the audit trail survives). The right-to-be-forgotten lever.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    grantId: { type: "string", description: "the grant id to revoke" },
+                },
+                required: ["grantId"],
+            },
+        },
+        {
+            name: "list_shares",
+            description: "List consent grants with their effective state, optionally filtered by subject / recipient / effectiveness. The audit + revoke surface.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    subjectKey: { type: "string", description: "filter to one subject — a friend uuid or a missionKey (the legacy arg name subjectFriendId is still accepted)" },
+                    recipientAgentId: { type: "string", description: "filter to one recipient agent" },
+                    effectiveOnly: { type: "string", enum: ["true", "false"], description: "set to 'true' to return only grants that currently consent" },
+                },
+            },
+        },
+        {
+            name: "record_mission",
+            description: "Upsert a shared mission (brick 3) by its cross-agent missionKey: create one when the key is unknown, else merge into the existing record. Appends first-party learnings / participants / outcomes and sets status. The mission analogue of record_interaction's outcome writer.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    missionKey: { type: "string", description: "the cross-agent join key for the mission (a ticket id / repo+PR / slugged name)" },
+                    title: { type: "string", description: "human title; used only when CREATING (ignored on upsert)" },
+                    status: { type: "string", enum: ["active", "succeeded", "partial", "failed", "abandoned"], description: "the mission status (first-party)" },
+                    participants: { type: "array", description: "agent attributions [{ agentId?, agentName? }], merged deduped by agentId" },
+                    learnings: { type: "array", description: "first-party learnings [{ key, value, shareable? }] appended to the mission" },
+                    outcomes: { type: "array", description: "first-party outcomes [{ missionId, result, note? }] appended to the mission" },
+                },
+                required: ["missionKey"],
+            },
+        },
+        {
+            name: "get_mission",
+            description: "Fetch a single mission record by its local uuid id.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    missionId: { type: "string", description: "the mission's local uuid id" },
+                },
+                required: ["missionId"],
+            },
+        },
+        {
+            name: "list_missions",
+            description: "List mission records, optionally limited.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    limit: { type: "string", description: "max number of records to return" },
+                },
+            },
+        },
+        {
+            name: "share_mission",
+            description: "Producer: prepare a consent-gated, scope-filtered, provenance-preserving mission-share envelope for another agent (names the mission by its missionKey, never the local uuid). Self identity comes from whoami. 'mission' carries the shareable learnings; 'outcomes' carries the mission's outcomes. Returns { ok, envelope } or { ok:false, status }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    missionId: { type: "string", description: "the local mission to share (its local uuid id)" },
+                    toAgentId: { type: "string", description: "the recipient agent's join-key agentId" },
+                    scope: { type: "string", enum: ["mission", "outcomes"], description: "what to share: 'mission' (title/status + shareable learnings) or 'outcomes' (the result rows); both require an explicit grant under the tiered policy" },
+                    proof: { type: "string", description: "optional opaque proof to stamp on the envelope (for a non-TOFU recipient verifier)" },
+                },
+                required: ["missionId", "toAgentId", "scope"],
+            },
+        },
+        {
+            name: "import_mission",
+            description: "Consumer (non-clobbering merge): import a mission-share envelope. Resolves the mission by missionKey; lands learnings in the imported namespace WITHOUT touching first-party learnings; append-merges + dedupes outcomes; source trust caps acceptance; never recomputes status/participants. Returns { ok, status, record }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    envelope: { type: "object", description: "the MissionShareEnvelope to import" },
+                    fromAgentId: { type: "string", description: "the agent the envelope arrived from (join-key agentId)" },
+                    trustOfSource: { type: "string", enum: ["family", "friend", "acquaintance", "stranger"], description: "this agent's resolved trust in the source agent — the acceptance cap" },
+                },
+                required: ["envelope", "fromAgentId", "trustOfSource"],
+            },
+        },
+        {
+            name: "coordinate",
+            description: "Producer (brick 5): prepare a coordination message that negotiates WHO does a mission — one of request/offer/accept/decline/handoff, named by the mission's missionKey (never the local uuid). Consent-gated via the identity-tier 'coordinate' scope (trust ≥ friend suffices). 'accept' claims the assignment for self; 'handoff' (you must hold the assignment) proposes a new assignee whose own accept confirms it (non-transitive). Self identity comes from whoami. Returns { ok, envelope } or { ok:false, status: not_found|no_consent|not_assignee }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    missionId: { type: "string", description: "the local mission to coordinate (its local uuid id)" },
+                    toAgentId: { type: "string", description: "the recipient agent's join-key agentId" },
+                    intent: { type: "string", enum: ["request", "offer", "accept", "decline", "handoff"], description: "the coordination verb: request (will you take this?) / offer (I'll take this) / accept (yes, I'm on it — sets assignee=self) / decline (no) / handoff (it's yours now — you must hold the assignment; proposes a new assignee)" },
+                    note: { type: "string", description: "optional free text carried on the message + logged" },
+                    proposedAssignee: { type: "object", description: "the proposed new assignee { agentId?, agentName? } — meaningful ONLY on intent=handoff" },
+                    proof: { type: "string", description: "optional opaque proof to stamp on the envelope (for a non-TOFU recipient verifier)" },
+                },
+                required: ["missionId", "toAgentId", "intent"],
+            },
+        },
+        {
+            name: "import_coordination",
+            description: "Consumer (brick 5, non-clobbering merge): import a coordination message. Resolves the mission by missionKey; appends the intent to coordination.log stamped origin:imported WITHOUT touching first-party learnings/notes/status; only an 'accept' sets the assignee (last-writer-wins by issuedAt); a 'handoff' never forces an assignee onto you (only your own accept does); never recomputes status/trust/standing; source trust caps acceptance; a friend/family peer may seed an unknown mission. Returns { ok, status: logged|assigned|seeded, record } or { ok:false, status }.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    envelope: { type: "object", description: "the CoordinationEnvelope to import" },
+                    fromAgentId: { type: "string", description: "the agent the envelope arrived from (join-key agentId)" },
+                    trustOfSource: { type: "string", enum: ["family", "friend", "acquaintance", "stranger"], description: "this agent's resolved trust in the source agent — the acceptance cap" },
+                },
+                required: ["envelope", "fromAgentId", "trustOfSource"],
+            },
+        },
+        {
+            name: "get_coordination",
+            description: "Read lens (brick 5): return a mission's coordination state — its current assignee (who holds it; absent ⇒ unclaimed) + the append-only log of every request/offer/accept/decline/handoff that flowed. Returns { assignee, assignedAt?, log } (the empty default { assignee: undefined, log: [] } when never coordinated), or { ok:false, status:'not_found' } when the mission is missing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    missionId: { type: "string", description: "the mission's local uuid id" },
+                },
+                required: ["missionId"],
+            },
+        },
+    ];
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,21 @@
+import type { FriendStore } from "../store";
+import type { GrantStore } from "../grant-store";
+import type { MissionStore } from "../mission-store";
+export interface FriendsMcpServerOptions {
+    store: FriendStore;
+    /** Optional consent-grant store. When omitted, the consent/share tools
+     * (grant_share / revoke_share / list_shares / share_profile) report
+     * `unsupported`; everything else works store-only. */
+    grants?: GrantStore;
+    /** Optional mission store. When omitted, the mission ledger tools
+     * (record_mission / get_mission / list_missions / share_mission /
+     * import_mission) report `unsupported`; everything else works without it. */
+    missions?: MissionStore;
+    stdin: NodeJS.ReadableStream;
+    stdout: NodeJS.WritableStream;
+}
+export interface FriendsMcpServer {
+    start(): void;
+    stop(): void;
+}
+export declare function createFriendsMcpServer(options: FriendsMcpServerOptions): FriendsMcpServer;

package/dist/mcp/server.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFriendsMcpServer = createFriendsMcpServer;
+// createFriendsMcpServer — a JSON-RPC 2.0 server over stdio for the friends
+// library. It runs NO agent turn, NO daemon, NO LLM: every tools/call is a pure
+// record read/write dispatched to the library. That is exactly what makes it
+// harness-agnostic.
+//
+// Dual stdio framing: Content-Length (Claude Code) and newline-delimited JSON
+// (Codex), auto-detected from the first message. The framing plumbing is ported
+// from the harness's MCP server with all conversation/socket machinery removed.
+const observability_1 = require("../observability");
+const schemas_1 = require("./schemas");
+const dispatch_1 = require("./dispatch");
+function createFriendsMcpServer(options) {
+    const { store, grants, missions, stdin, stdout } = options;
+    let buffer = "";
+    let running = false;
+    let useContentLengthFraming = true;
+    let framingDetected = false;
+    function writeResponse(response) {
+        const body = JSON.stringify(response);
+        if (useContentLengthFraming) {
+            stdout.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+        }
+        else {
+            stdout.write(body + "\n");
+        }
+    }
+    function tryParseContentLength() {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        /* v8 ignore next -- partial header delivery only in real I/O @preserve */
+        if (headerEnd === -1)
+            return false;
+        const headerSection = buffer.slice(0, headerEnd);
+        const contentLengthMatch = headerSection.match(/Content-Length:\s*(\d+)/i);
+        if (!contentLengthMatch) {
+            buffer = buffer.slice(headerEnd + 4);
+            return true;
+        }
+        const contentLength = parseInt(contentLengthMatch[1], 10);
+        const bodyStart = headerEnd + 4;
+        /* v8 ignore next -- partial body delivery only in real I/O @preserve */
+        if (buffer.length < bodyStart + contentLength)
+            return false;
+        const body = buffer.slice(bodyStart, bodyStart + contentLength);
+        buffer = buffer.slice(bodyStart + contentLength);
+        parseAndDispatch(body);
+        return true;
+    }
+    function tryParseNewlineDelimited() {
+        const newlineIdx = buffer.indexOf("\n");
+        /* v8 ignore next -- partial line delivery only in real I/O @preserve */
+        if (newlineIdx === -1)
+            return false;
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (line.length === 0)
+            return true;
+        parseAndDispatch(line);
+        return true;
+    }
+    function parseAndDispatch(body) {
+        let request;
+        try {
+            request = JSON.parse(body);
+        }
+        catch {
+            writeResponse({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+            return;
+        }
+        void handleRequest(request);
+    }
+    function handleData(chunk) {
+        buffer += chunk.toString("utf-8");
+        if (!framingDetected && buffer.length > 0) {
+            useContentLengthFraming = buffer.startsWith("Content-Length:");
+            framingDetected = true;
+        }
+        while (buffer.length > 0) {
+            const hasContentLength = buffer.startsWith("Content-Length:");
+            const parsed = hasContentLength ? tryParseContentLength() : tryParseNewlineDelimited();
+            /* v8 ignore next -- break on partial message only in real I/O @preserve */
+            if (!parsed)
+                break;
+        }
+    }
+    async function handleRequest(request) {
+        (0, observability_1.emitNervesEvent)({
+            component: "clients",
+            event: "clients.mcp_request_start",
+            message: "handling friends mcp request",
+            meta: { method: request.method },
+        });
+        if (request.id === undefined) {
+            (0, observability_1.emitNervesEvent)({
+                component: "clients",
+                event: "clients.mcp_request_end",
+                message: "handled friends mcp notification",
+                meta: { method: request.method },
+            });
+            return;
+        }
+        switch (request.method) {
+            case "initialize":
+                handleInitialize(request.id);
+                break;
+            case "tools/list":
+                handleToolsList(request.id);
+                break;
+            case "tools/call":
+                await handleToolsCall(request);
+                break;
+            default:
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    error: { code: -32601, message: `Method not found: ${request.method}` },
+                });
+                break;
+        }
+        (0, observability_1.emitNervesEvent)({
+            component: "clients",
+            event: "clients.mcp_request_end",
+            message: "completed friends mcp request",
+            meta: { method: request.method },
+        });
+    }
+    function handleInitialize(id) {
+        writeResponse({
+            jsonrpc: "2.0",
+            id,
+            result: {
+                protocolVersion: "2024-11-05",
+                serverInfo: { name: "friends-mcp-server", version: "0.1.0" },
+                capabilities: { tools: { listChanged: false } },
+            },
+        });
+    }
+    function handleToolsList(id) {
+        writeResponse({ jsonrpc: "2.0", id, result: { tools: (0, schemas_1.getToolSchemas)() } });
+    }
+    async function handleToolsCall(request) {
+        const params = request.params ?? {};
+        const toolName = params.name ?? "";
+        const toolArgs = params.arguments ?? {};
+        try {
+            const { result, isError } = await (0, dispatch_1.dispatchTool)(store, toolName, toolArgs, grants, missions);
+            writeResponse({
+                jsonrpc: "2.0",
+                id: request.id,
+                result: { content: [{ type: "text", text: JSON.stringify(result) }], isError },
+            });
+        }
+        catch (error) {
+            /* v8 ignore next -- defensive: non-Error throw is unreachable; tests inject Error @preserve */
+            const message = error instanceof Error ? error.message : String(error);
+            writeResponse({
+                jsonrpc: "2.0",
+                id: request.id,
+                result: { content: [{ type: "text", text: `Error: ${message}` }], isError: true },
+            });
+        }
+    }
+    function onData(chunk) {
+        handleData(chunk);
+    }
+    return {
+        start() {
+            if (running)
+                return;
+            running = true;
+            stdin.on("data", onData);
+            (0, observability_1.emitNervesEvent)({
+                component: "clients",
+                event: "clients.mcp_server_start",
+                message: "friends mcp server started",
+                meta: {},
+            });
+        },
+        stop() {
+            if (!running)
+                return;
+            running = false;
+            stdin.removeListener("data", onData);
+            (0, observability_1.emitNervesEvent)({
+                component: "clients",
+                event: "clients.mcp_server_end",
+                message: "friends mcp server stopped",
+                meta: {},
+            });
+        },
+    };
+}