@ouro.bot/friends 0.1.0-alpha.4

package/dist/group-context.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertGroupContextParticipants = upsertGroupContextParticipants;
+const node_crypto_1 = require("node:crypto");
+const observability_1 = require("./observability");
+const CURRENT_SCHEMA_VERSION = 1;
+function normalizeDisplayName(externalId, displayName) {
+    const trimmed = displayName?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : externalId;
+}
+function buildNameNotes(name, now) {
+    return name !== "Unknown"
+        ? { name: { value: name, savedAt: now } }
+        : {};
+}
+function dedupeParticipants(participants) {
+    const deduped = new Map();
+    for (const participant of participants) {
+        const externalId = participant.externalId.trim();
+        if (!externalId)
+            continue;
+        const key = `${participant.provider}:${externalId}`;
+        if (!deduped.has(key)) {
+            deduped.set(key, {
+                ...participant,
+                externalId,
+                displayName: participant.displayName?.trim() || undefined,
+            });
+        }
+    }
+    return Array.from(deduped.values());
+}
+function createGroupExternalId(provider, groupExternalId, linkedAt) {
+    return {
+        provider,
+        externalId: groupExternalId,
+        linkedAt,
+    };
+}
+function shouldPromoteToAcquaintance(friend) {
+    return (friend.trustLevel ?? "stranger") === "stranger";
+}
+function createAcquaintanceRecord(participant, groupExternalId, linkedAt) {
+    const name = normalizeDisplayName(participant.externalId, participant.displayName);
+    return {
+        id: (0, node_crypto_1.randomUUID)(),
+        name,
+        role: "acquaintance",
+        trustLevel: "acquaintance",
+        connections: [],
+        externalIds: [
+            {
+                provider: participant.provider,
+                externalId: participant.externalId,
+                linkedAt,
+            },
+            createGroupExternalId(participant.provider, groupExternalId, linkedAt),
+        ],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: buildNameNotes(name, linkedAt),
+        totalTokens: 0,
+        createdAt: linkedAt,
+        updatedAt: linkedAt,
+        schemaVersion: CURRENT_SCHEMA_VERSION,
+    };
+}
+async function upsertGroupContextParticipants(input) {
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.group_context_upsert_start",
+        message: "upserting shared-group participant context",
+        meta: {
+            participantCount: input.participants.length,
+            hasGroupExternalId: input.groupExternalId.trim().length > 0,
+        },
+    });
+    const groupExternalId = input.groupExternalId.trim();
+    if (!groupExternalId) {
+        return [];
+    }
+    const now = input.now ?? (() => new Date().toISOString());
+    const participants = dedupeParticipants(input.participants);
+    const results = [];
+    for (const participant of participants) {
+        const linkedAt = now();
+        const existing = await input.store.findByExternalId(participant.provider, participant.externalId);
+        if (!existing) {
+            const created = createAcquaintanceRecord(participant, groupExternalId, linkedAt);
+            await input.store.put(created.id, created);
+            results.push({
+                friendId: created.id,
+                name: created.name,
+                trustLevel: "acquaintance",
+                created: true,
+                updated: false,
+                addedGroupExternalId: true,
+            });
+            continue;
+        }
+        const hasGroupExternalId = existing.externalIds.some((externalId) => externalId.externalId === groupExternalId);
+        const promoteToAcquaintance = shouldPromoteToAcquaintance(existing);
+        const trustLevel = promoteToAcquaintance
+            ? "acquaintance"
+            : existing.trustLevel;
+        const role = promoteToAcquaintance
+            ? "acquaintance"
+            : existing.role;
+        const updatedExternalIds = hasGroupExternalId
+            ? existing.externalIds
+            : [...existing.externalIds, createGroupExternalId(participant.provider, groupExternalId, linkedAt)];
+        const updated = promoteToAcquaintance || !hasGroupExternalId;
+        const record = updated
+            ? {
+                ...existing,
+                role,
+                trustLevel,
+                externalIds: updatedExternalIds,
+                updatedAt: linkedAt,
+            }
+            : existing;
+        if (updated) {
+            await input.store.put(record.id, record);
+        }
+        results.push({
+            friendId: record.id,
+            name: record.name,
+            trustLevel,
+            created: false,
+            updated,
+            addedGroupExternalId: !hasGroupExternalId,
+        });
+    }
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.group_context_upsert_end",
+        message: "upserted shared-group participant context",
+        meta: {
+            participantCount: participants.length,
+            updatedCount: results.filter((result) => result.created || result.updated).length,
+        },
+    });
+    return results;
+}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+export type { FriendRecord, FriendConnection, ExternalId, IdentityProvider, Integration, Channel, TrustLevel, AgentMeta, AgentAttribution, RelationshipOutcome, NoteProvenance, ImportedNote, ShareScope, ShareGrant, MissionKey, MissionLearning, ImportedLearning, MissionRecord, CoordinationIntent, CoordinationLogEntry, MissionCoordination, ChannelCapabilities, ResolvedContext, SenseType, } from "./types";
+export type { Facing } from "./channel";
+export type { TrustExplanation, TrustBasis } from "./trust-explanation";
+export type { Standing, StandingTier, StandingTally, StandingExplanation, StandingRule, StandingRuleInput, } from "./standing";
+export type { FriendStore } from "./store";
+export type { GrantStore } from "./grant-store";
+export type { MissionStore } from "./mission-store";
+export type { FriendResolverParams } from "./resolver";
+export type { GroupContextParticipant, GroupContextUpsertResult, } from "./group-context";
+export type { UsageData } from "./tokens";
+export type { FriendOpResult, FriendOpStatus } from "./results";
+export type { ApplyFriendNoteInput } from "./notes";
+export type { RoomView, RoomMember, RoomKnownVia } from "./room";
+export type { ConsentPolicy, ConsentRecipient, ConsentDecisionInput, } from "./consent";
+export type { AgentVerifier } from "./verifier";
+export type { ProfileShareEnvelope, SharedNote, PrepareProfileShareInput, PrepareProfileShareResult, PrepareProfileShareStatus, ImportProfileShareInput, ImportProfileShareOptions, ImportProfileShareResult, ImportProfileShareStatus, } from "./share";
+export type { GrantShareInput, RevokeShareResult, ListSharesFilter, ListedShare, } from "./grants";
+export { TRUSTED_LEVELS, IDENTITY_SCOPES, isTrustedLevel, isIdentityProvider, isIntegration, isShareScope, isCoordinationIntent, } from "./types";
+export { FileFriendStore } from "./store-file";
+export { FileGrantStore, grantsDirFor } from "./grant-store-file";
+export { FileMissionStore, missionsDirFor } from "./mission-store-file";
+export { openFileBundle } from "./file-bundle";
+export type { FileBundle } from "./file-bundle";
+export { FriendResolver, machineOwnerUsername, isLocalMachineOwnerIdentity, _setMachineOwnerUsernameForTest, } from "./resolver";
+export { getChannelCapabilities, channelToFacing, isRemoteChannel, getAlwaysOnSenseNames, } from "./channel";
+export { describeTrustContext } from "./trust-explanation";
+export { assessStanding, explainStanding, DEFAULT_STANDING_RULE } from "./standing";
+export { upsertGroupContextParticipants } from "./group-context";
+export { accumulateFriendTokens } from "./tokens";
+export { applyFriendNote } from "./notes";
+export { setFriendTrust } from "./trust-mutation";
+export { linkExternalId, unlinkExternalId } from "./link-identity";
+export { upsertAgentPeer } from "./agent-peer";
+export { recordRelationshipOutcome } from "./outcomes";
+export { recordMission } from "./missions";
+export type { RecordMissionInput } from "./missions";
+export { whoami } from "./whoami";
+export type { WhoamiResult } from "./whoami";
+export { resolveRoom } from "./room";
+export { strictPolicy, trustImpliedPolicy, tieredPolicy, DEFAULT_CONSENT_POLICY, } from "./consent";
+export { tofuVerifier, DEFAULT_AGENT_VERIFIER } from "./verifier";
+export { prepareProfileShare, importProfileShare } from "./share";
+export { prepareMissionShare, importMissionShare } from "./mission-share";
+export type { MissionShareEnvelope, SharedLearning, PrepareMissionShareInput, PrepareMissionShareResult, PrepareMissionShareStatus, ImportMissionShareInput, ImportMissionShareOptions, ImportMissionShareResult, ImportMissionShareStatus, } from "./mission-share";
+export { prepareCoordination, importCoordination } from "./coordination";
+export type { CoordinationEnvelope, PrepareCoordinationInput, PrepareCoordinationResult, PrepareCoordinationStatus, ImportCoordinationInput, ImportCoordinationOptions, ImportCoordinationResult, ImportCoordinationStatus, } from "./coordination";
+export { grantShare, revokeShare, listShares, isGrantEffective } from "./grants";
+export { emitNervesEvent, setNervesEmitter, } from "./observability";
+export type { NervesEvent, NervesEmitter, LogLevel } from "./observability";

package/dist/index.js

@@ -0,0 +1,105 @@
+"use strict";
+// @ouro.bot/friends — public API barrel.
+//
+// The who's-who / identity / relationship substrate for agents: a trust ladder
+// (family / friend / acquaintance / stranger), multi-party (group) and
+// multi-agent (a2a peer) aware, consumed through the FriendStore interface +
+// FriendResolver.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeShare = exports.grantShare = exports.importCoordination = exports.prepareCoordination = exports.importMissionShare = exports.prepareMissionShare = exports.importProfileShare = exports.prepareProfileShare = exports.DEFAULT_AGENT_VERIFIER = exports.tofuVerifier = exports.DEFAULT_CONSENT_POLICY = exports.tieredPolicy = exports.trustImpliedPolicy = exports.strictPolicy = exports.resolveRoom = exports.whoami = exports.recordMission = exports.recordRelationshipOutcome = exports.upsertAgentPeer = exports.unlinkExternalId = exports.linkExternalId = exports.setFriendTrust = exports.applyFriendNote = exports.accumulateFriendTokens = exports.upsertGroupContextParticipants = exports.DEFAULT_STANDING_RULE = exports.explainStanding = exports.assessStanding = exports.describeTrustContext = exports.getAlwaysOnSenseNames = exports.isRemoteChannel = exports.channelToFacing = exports.getChannelCapabilities = exports._setMachineOwnerUsernameForTest = exports.isLocalMachineOwnerIdentity = exports.machineOwnerUsername = exports.FriendResolver = exports.openFileBundle = exports.missionsDirFor = exports.FileMissionStore = exports.grantsDirFor = exports.FileGrantStore = exports.FileFriendStore = exports.isCoordinationIntent = exports.isShareScope = exports.isIntegration = exports.isIdentityProvider = exports.isTrustedLevel = exports.IDENTITY_SCOPES = exports.TRUSTED_LEVELS = void 0;
+exports.setNervesEmitter = exports.emitNervesEvent = exports.isGrantEffective = exports.listShares = void 0;
+// -- Values --
+var types_1 = require("./types");
+Object.defineProperty(exports, "TRUSTED_LEVELS", { enumerable: true, get: function () { return types_1.TRUSTED_LEVELS; } });
+Object.defineProperty(exports, "IDENTITY_SCOPES", { enumerable: true, get: function () { return types_1.IDENTITY_SCOPES; } });
+Object.defineProperty(exports, "isTrustedLevel", { enumerable: true, get: function () { return types_1.isTrustedLevel; } });
+Object.defineProperty(exports, "isIdentityProvider", { enumerable: true, get: function () { return types_1.isIdentityProvider; } });
+Object.defineProperty(exports, "isIntegration", { enumerable: true, get: function () { return types_1.isIntegration; } });
+Object.defineProperty(exports, "isShareScope", { enumerable: true, get: function () { return types_1.isShareScope; } });
+Object.defineProperty(exports, "isCoordinationIntent", { enumerable: true, get: function () { return types_1.isCoordinationIntent; } });
+var store_file_1 = require("./store-file");
+Object.defineProperty(exports, "FileFriendStore", { enumerable: true, get: function () { return store_file_1.FileFriendStore; } });
+var grant_store_file_1 = require("./grant-store-file");
+Object.defineProperty(exports, "FileGrantStore", { enumerable: true, get: function () { return grant_store_file_1.FileGrantStore; } });
+Object.defineProperty(exports, "grantsDirFor", { enumerable: true, get: function () { return grant_store_file_1.grantsDirFor; } });
+var mission_store_file_1 = require("./mission-store-file");
+Object.defineProperty(exports, "FileMissionStore", { enumerable: true, get: function () { return mission_store_file_1.FileMissionStore; } });
+Object.defineProperty(exports, "missionsDirFor", { enumerable: true, get: function () { return mission_store_file_1.missionsDirFor; } });
+var file_bundle_1 = require("./file-bundle");
+Object.defineProperty(exports, "openFileBundle", { enumerable: true, get: function () { return file_bundle_1.openFileBundle; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "FriendResolver", { enumerable: true, get: function () { return resolver_1.FriendResolver; } });
+Object.defineProperty(exports, "machineOwnerUsername", { enumerable: true, get: function () { return resolver_1.machineOwnerUsername; } });
+Object.defineProperty(exports, "isLocalMachineOwnerIdentity", { enumerable: true, get: function () { return resolver_1.isLocalMachineOwnerIdentity; } });
+Object.defineProperty(exports, "_setMachineOwnerUsernameForTest", { enumerable: true, get: function () { return resolver_1._setMachineOwnerUsernameForTest; } });
+var channel_1 = require("./channel");
+Object.defineProperty(exports, "getChannelCapabilities", { enumerable: true, get: function () { return channel_1.getChannelCapabilities; } });
+Object.defineProperty(exports, "channelToFacing", { enumerable: true, get: function () { return channel_1.channelToFacing; } });
+Object.defineProperty(exports, "isRemoteChannel", { enumerable: true, get: function () { return channel_1.isRemoteChannel; } });
+Object.defineProperty(exports, "getAlwaysOnSenseNames", { enumerable: true, get: function () { return channel_1.getAlwaysOnSenseNames; } });
+var trust_explanation_1 = require("./trust-explanation");
+Object.defineProperty(exports, "describeTrustContext", { enumerable: true, get: function () { return trust_explanation_1.describeTrustContext; } });
+// -- Earned standing (brick four): advisory, first-party, derived; never writes trust --
+var standing_1 = require("./standing");
+Object.defineProperty(exports, "assessStanding", { enumerable: true, get: function () { return standing_1.assessStanding; } });
+Object.defineProperty(exports, "explainStanding", { enumerable: true, get: function () { return standing_1.explainStanding; } });
+Object.defineProperty(exports, "DEFAULT_STANDING_RULE", { enumerable: true, get: function () { return standing_1.DEFAULT_STANDING_RULE; } });
+var group_context_1 = require("./group-context");
+Object.defineProperty(exports, "upsertGroupContextParticipants", { enumerable: true, get: function () { return group_context_1.upsertGroupContextParticipants; } });
+var tokens_1 = require("./tokens");
+Object.defineProperty(exports, "accumulateFriendTokens", { enumerable: true, get: function () { return tokens_1.accumulateFriendTokens; } });
+var notes_1 = require("./notes");
+Object.defineProperty(exports, "applyFriendNote", { enumerable: true, get: function () { return notes_1.applyFriendNote; } });
+var trust_mutation_1 = require("./trust-mutation");
+Object.defineProperty(exports, "setFriendTrust", { enumerable: true, get: function () { return trust_mutation_1.setFriendTrust; } });
+var link_identity_1 = require("./link-identity");
+Object.defineProperty(exports, "linkExternalId", { enumerable: true, get: function () { return link_identity_1.linkExternalId; } });
+Object.defineProperty(exports, "unlinkExternalId", { enumerable: true, get: function () { return link_identity_1.unlinkExternalId; } });
+var agent_peer_1 = require("./agent-peer");
+Object.defineProperty(exports, "upsertAgentPeer", { enumerable: true, get: function () { return agent_peer_1.upsertAgentPeer; } });
+var outcomes_1 = require("./outcomes");
+Object.defineProperty(exports, "recordRelationshipOutcome", { enumerable: true, get: function () { return outcomes_1.recordRelationshipOutcome; } });
+var missions_1 = require("./missions");
+Object.defineProperty(exports, "recordMission", { enumerable: true, get: function () { return missions_1.recordMission; } });
+var whoami_1 = require("./whoami");
+Object.defineProperty(exports, "whoami", { enumerable: true, get: function () { return whoami_1.whoami; } });
+var room_1 = require("./room");
+Object.defineProperty(exports, "resolveRoom", { enumerable: true, get: function () { return room_1.resolveRoom; } });
+// -- Cross-agent moat (N12): consent · share · import --
+// The consent posture is a one-line swap: DEFAULT_CONSENT_POLICY in consent.ts
+// (the SWAP POINT). strictPolicy / trustImpliedPolicy / tieredPolicy are the
+// three selectable postures; tieredPolicy is the default.
+var consent_1 = require("./consent");
+Object.defineProperty(exports, "strictPolicy", { enumerable: true, get: function () { return consent_1.strictPolicy; } });
+Object.defineProperty(exports, "trustImpliedPolicy", { enumerable: true, get: function () { return consent_1.trustImpliedPolicy; } });
+Object.defineProperty(exports, "tieredPolicy", { enumerable: true, get: function () { return consent_1.tieredPolicy; } });
+Object.defineProperty(exports, "DEFAULT_CONSENT_POLICY", { enumerable: true, get: function () { return consent_1.DEFAULT_CONSENT_POLICY; } });
+var verifier_1 = require("./verifier");
+Object.defineProperty(exports, "tofuVerifier", { enumerable: true, get: function () { return verifier_1.tofuVerifier; } });
+Object.defineProperty(exports, "DEFAULT_AGENT_VERIFIER", { enumerable: true, get: function () { return verifier_1.DEFAULT_AGENT_VERIFIER; } });
+var share_1 = require("./share");
+Object.defineProperty(exports, "prepareProfileShare", { enumerable: true, get: function () { return share_1.prepareProfileShare; } });
+Object.defineProperty(exports, "importProfileShare", { enumerable: true, get: function () { return share_1.importProfileShare; } });
+var mission_share_1 = require("./mission-share");
+Object.defineProperty(exports, "prepareMissionShare", { enumerable: true, get: function () { return mission_share_1.prepareMissionShare; } });
+Object.defineProperty(exports, "importMissionShare", { enumerable: true, get: function () { return mission_share_1.importMissionShare; } });
+// -- Coordination / delegation (brick five): negotiate WHO does a mission --
+// Five verbs (request/offer/accept/decline/handoff) over kind:"coordination";
+// the ONLY persisted effect is the mission's `coordination` sub-object (assignee +
+// an append-only log). Trust-gated + consent-gated (the "coordinate" scope),
+// first-party-inviolable, non-transitive (a handoff never forces an assignee).
+var coordination_1 = require("./coordination");
+Object.defineProperty(exports, "prepareCoordination", { enumerable: true, get: function () { return coordination_1.prepareCoordination; } });
+Object.defineProperty(exports, "importCoordination", { enumerable: true, get: function () { return coordination_1.importCoordination; } });
+var grants_1 = require("./grants");
+Object.defineProperty(exports, "grantShare", { enumerable: true, get: function () { return grants_1.grantShare; } });
+Object.defineProperty(exports, "revokeShare", { enumerable: true, get: function () { return grants_1.revokeShare; } });
+Object.defineProperty(exports, "listShares", { enumerable: true, get: function () { return grants_1.listShares; } });
+Object.defineProperty(exports, "isGrantEffective", { enumerable: true, get: function () { return grants_1.isGrantEffective; } });
+// -- Observability seam --
+// The package emits structured events through a no-op `emitNervesEvent` by
+// default. Pass a real emitter via `setNervesEmitter` to forward them (the
+// harness wires its nerves emitter here).
+var observability_1 = require("./observability");
+Object.defineProperty(exports, "emitNervesEvent", { enumerable: true, get: function () { return observability_1.emitNervesEvent; } });
+Object.defineProperty(exports, "setNervesEmitter", { enumerable: true, get: function () { return observability_1.setNervesEmitter; } });

package/dist/link-identity.d.ts

@@ -0,0 +1,14 @@
+import type { FriendStore } from "./store";
+import type { IdentityProvider } from "./types";
+import type { FriendOpResult } from "./results";
+export interface LinkExternalIdInput {
+    provider: IdentityProvider;
+    externalId: string;
+    tenantId?: string;
+}
+export declare function linkExternalId(store: FriendStore, friendId: string, input: LinkExternalIdInput): Promise<FriendOpResult>;
+export interface UnlinkExternalIdInput {
+    provider: IdentityProvider;
+    externalId: string;
+}
+export declare function unlinkExternalId(store: FriendStore, friendId: string, input: UnlinkExternalIdInput): Promise<FriendOpResult>;

package/dist/link-identity.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkExternalId = linkExternalId;
+exports.unlinkExternalId = unlinkExternalId;
+// linkExternalId / unlinkExternalId — structured-result port of the harness's
+// `friend.link` / `friend.unlink`.
+//
+// Linking is the cross-channel unification mechanic: when another friend record
+// (an "orphan") already holds the external id being linked, the two records are
+// merged into the target — the target's notes win on key collision, the higher
+// trust level is kept, the orphan's other external ids are folded in, and the
+// orphan is deleted. A missing friend is a normal `not_found` result.
+const observability_1 = require("./observability");
+const TRUST_RANK = { family: 4, friend: 3, acquaintance: 2, stranger: 1 };
+/* v8 ignore start -- defensive: ?? fallbacks are unreachable when inputs are valid TrustLevel values @preserve */
+function higherTrust(a, b) {
+    const rankA = TRUST_RANK[a ?? "stranger"] ?? 1;
+    const rankB = TRUST_RANK[b ?? "stranger"] ?? 1;
+    return rankA >= rankB ? (a ?? "stranger") : (b ?? "stranger");
+}
+async function linkExternalId(store, friendId, input) {
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.identity_linked",
+        message: "linked external identity",
+        meta: { provider: input.provider },
+    });
+    const current = await store.get(friendId);
+    if (!current) {
+        return { ok: false, status: "not_found", message: "friend record not found" };
+    }
+    const alreadyLinked = current.externalIds.some((ext) => ext.provider === input.provider && ext.externalId === input.externalId);
+    if (alreadyLinked) {
+        return { ok: true, status: "noop", message: "identity already linked", record: current };
+    }
+    const now = new Date().toISOString();
+    const linked = {
+        provider: input.provider,
+        externalId: input.externalId,
+        linkedAt: now,
+        ...(input.tenantId !== undefined ? { tenantId: input.tenantId } : {}),
+    };
+    const newExternalIds = [...current.externalIds, linked];
+    // Orphan cleanup: find another friend holding this external id. Matched
+    // WITHOUT tenantId (D4) so orphan-merge fires across tenant-unqualified
+    // records even when this link carries a tenantId.
+    const orphan = await store.findByExternalId(input.provider, input.externalId);
+    let mergedNotes = { ...current.notes };
+    let mergedTrust = current.trustLevel;
+    let orphanExternalIds = [];
+    let merged = false;
+    if (orphan && orphan.id !== friendId) {
+        mergedNotes = { ...orphan.notes, ...current.notes };
+        mergedTrust = higherTrust(current.trustLevel, orphan.trustLevel);
+        orphanExternalIds = orphan.externalIds.filter((ext) => !(ext.provider === input.provider && ext.externalId === input.externalId));
+        await store.delete(orphan.id);
+        merged = true;
+    }
+    const updated = {
+        ...current,
+        externalIds: [...newExternalIds, ...orphanExternalIds],
+        notes: mergedNotes,
+        trustLevel: mergedTrust,
+        updatedAt: now,
+    };
+    await store.put(friendId, updated);
+    return { ok: true, status: merged ? "merged" : "linked", record: updated };
+}
+async function unlinkExternalId(store, friendId, input) {
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.identity_unlinked",
+        message: "unlinked external identity",
+        meta: { provider: input.provider },
+    });
+    const current = await store.get(friendId);
+    if (!current) {
+        return { ok: false, status: "not_found", message: "friend record not found" };
+    }
+    const idx = current.externalIds.findIndex((ext) => ext.provider === input.provider && ext.externalId === input.externalId);
+    if (idx === -1) {
+        return { ok: false, status: "noop", message: "identity not linked" };
+    }
+    const filtered = current.externalIds.filter((_, i) => i !== idx);
+    const updated = { ...current, externalIds: filtered, updatedAt: new Date().toISOString() };
+    await store.put(friendId, updated);
+    return { ok: true, status: "unlinked", record: updated };
+}

package/dist/mcp/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp/bin.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// friends-mcp — stdio entrypoint for the friends MCP server.
+//
+// Thin wrapper: all arg-parsing and store construction live in `runMain` (which
+// is covered by tests). This file is the only module excluded from coverage —
+// its sole uncovered lines are the process wiring below.
+const run_main_1 = require("./run-main");
+(0, run_main_1.runMain)(process.argv, process.env, {
+    stdin: process.stdin,
+    stdout: process.stdout,
+    onError: () => {
+        process.exitCode = 1;
+    },
+});

package/dist/mcp/dispatch.d.ts

@@ -0,0 +1,14 @@
+import type { FriendStore } from "../store";
+import type { GrantStore } from "../grant-store";
+import type { MissionStore } from "../mission-store";
+type Args = Record<string, unknown>;
+export interface DispatchResult {
+    result: unknown;
+    isError: boolean;
+}
+export declare function coerceBool(v: unknown): boolean;
+export declare function coerceInt(v: unknown): number | undefined;
+export declare function coerceString(v: unknown): string;
+export declare function coerceOptionalString(v: unknown): string | undefined;
+export declare function dispatchTool(store: FriendStore, name: string, args: Args, grants?: GrantStore, missions?: MissionStore): Promise<DispatchResult>;
+export {};