@ouro.bot/friends 0.1.0-alpha.4

package/dist/store-file.js

@@ -0,0 +1,264 @@
+"use strict";
+// FileFriendStore -- filesystem adapter for FriendStore.
+// Stores each friend as one unified JSON file in bundle `friends/`.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileFriendStore = void 0;
+const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const cap_string_1 = require("./util/cap-string");
+const observability_1 = require("./observability");
+const DEFAULT_ROLE = "friend";
+const DEFAULT_TRUST_LEVEL = "friend";
+class FileFriendStore {
+    friendsPath;
+    constructor(friendsPath) {
+        this.friendsPath = friendsPath;
+        fs.mkdirSync(friendsPath, { recursive: true });
+        (0, observability_1.emitNervesEvent)({
+            component: "friends",
+            event: "friends.store_init",
+            message: "file friend store initialized",
+            meta: {},
+        });
+    }
+    async get(id) {
+        // Direct UUID lookup
+        const record = await this.readJson(path.join(this.friendsPath, `${id}.json`));
+        if (record)
+            return this.normalize(record);
+        // Fallback: if id is a name (not UUID), scan for matching friend
+        /* v8 ignore start -- name fallback: exercised by live proactive sends @preserve */
+        try {
+            const entries = await fsPromises.readdir(this.friendsPath);
+            for (const entry of entries) {
+                if (!entry.endsWith(".json"))
+                    continue;
+                const raw = await this.readJson(path.join(this.friendsPath, entry));
+                if (!raw)
+                    continue;
+                const normalized = this.normalize(raw);
+                if (normalized.name?.toLowerCase() === id.toLowerCase()) {
+                    return normalized;
+                }
+            }
+        }
+        catch { /* directory unreadable — return null */ }
+        /* v8 ignore stop */
+        return null;
+    }
+    async put(id, record) {
+        await this.writeJson(path.join(this.friendsPath, `${id}.json`), this.normalize(record));
+    }
+    async delete(id) {
+        await this.removeFile(path.join(this.friendsPath, `${id}.json`));
+    }
+    async findByExternalId(provider, externalId, tenantId) {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return null;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await this.readJson(path.join(this.friendsPath, entry));
+            if (!raw)
+                continue;
+            const record = this.normalize(raw);
+            const match = record.externalIds.some((ext) => ext.provider === provider &&
+                ext.externalId === externalId &&
+                (tenantId === undefined || ext.tenantId === tenantId));
+            if (match) {
+                return record;
+            }
+        }
+        return null;
+    }
+    async hasAnyFriends() {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return false;
+        }
+        return entries.some((entry) => entry.endsWith(".json"));
+    }
+    async listAll() {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return [];
+        }
+        const records = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await this.readJson(path.join(this.friendsPath, entry));
+            if (!raw)
+                continue;
+            records.push(this.normalize(raw));
+        }
+        return records;
+    }
+    normalize(raw) {
+        const trustLevel = raw.trustLevel;
+        const normalizedTrustLevel = trustLevel === "family" ||
+            trustLevel === "friend" ||
+            trustLevel === "acquaintance" ||
+            trustLevel === "stranger"
+            ? trustLevel
+            : DEFAULT_TRUST_LEVEL;
+        const kind = raw.kind === "human" || raw.kind === "agent" ? raw.kind : "human";
+        const agentMeta = kind === "agent" ? this.normalizeAgentMeta(raw.agentMeta) : undefined;
+        return {
+            id: raw.id,
+            name: raw.name,
+            role: typeof raw.role === "string" && raw.role.trim() ? raw.role : DEFAULT_ROLE,
+            trustLevel: normalizedTrustLevel,
+            connections: Array.isArray(raw.connections)
+                ? raw.connections
+                    .filter((connection) => (typeof connection === "object" &&
+                    connection !== null &&
+                    typeof connection.name === "string" &&
+                    typeof connection.relationship === "string"))
+                    .map((connection) => ({
+                    name: connection.name,
+                    relationship: connection.relationship,
+                }))
+                : [],
+            externalIds: Array.isArray(raw.externalIds) ? raw.externalIds : [],
+            tenantMemberships: Array.isArray(raw.tenantMemberships) ? raw.tenantMemberships : [],
+            toolPreferences: raw.toolPreferences && typeof raw.toolPreferences === "object"
+                ? raw.toolPreferences
+                : {},
+            notes: raw.notes && typeof raw.notes === "object" ? raw.notes : {},
+            // Imported facts (the cross-agent share namespace) are preserved verbatim
+            // when present. Absent on records that have never imported anything.
+            ...(raw.importedNotes && typeof raw.importedNotes === "object" && !Array.isArray(raw.importedNotes)
+                ? { importedNotes: raw.importedNotes }
+                : {}),
+            totalTokens: typeof raw.totalTokens === "number" ? raw.totalTokens : 0,
+            createdAt: typeof raw.createdAt === "string" ? raw.createdAt : new Date().toISOString(),
+            updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date().toISOString(),
+            schemaVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : 1,
+            kind,
+            agentMeta,
+        };
+    }
+    normalizeAgentMeta(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const meta = raw;
+        if (typeof meta.bundleName !== "string")
+            return undefined;
+        return {
+            bundleName: meta.bundleName,
+            familiarity: typeof meta.familiarity === "number" ? meta.familiarity : 0,
+            sharedMissions: Array.isArray(meta.sharedMissions) ? meta.sharedMissions : [],
+            outcomes: Array.isArray(meta.outcomes) ? meta.outcomes : [],
+            ...(this.normalizeA2AMeta(meta.a2a) ? { a2a: this.normalizeA2AMeta(meta.a2a) } : {}),
+        };
+    }
+    normalizeA2AMeta(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const meta = raw;
+        const mailbox = this.normalizeMailbox(meta.mailbox);
+        const a2a = {
+            ...(typeof meta.cardUrl === "string" ? { cardUrl: meta.cardUrl } : {}),
+            ...(typeof meta.endpointUrl === "string" ? { endpointUrl: meta.endpointUrl } : {}),
+            ...(typeof meta.agentId === "string" ? { agentId: meta.agentId } : {}),
+            ...(typeof meta.protocolVersion === "string" ? { protocolVersion: meta.protocolVersion } : {}),
+            ...(mailbox ? { mailbox } : {}),
+        };
+        return Object.keys(a2a).length > 0 ? a2a : undefined;
+    }
+    /** Preserve an additive a2a.mailbox coord only when both fields are strings;
+     * otherwise drop it (absent ⇒ unchanged — the additive guarantee). */
+    normalizeMailbox(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const m = raw;
+        if (typeof m.repo !== "string" || typeof m.selfOutboxAgentId !== "string")
+            return undefined;
+        return { repo: m.repo, selfOutboxAgentId: m.selfOutboxAgentId };
+    }
+    async readJson(filePath) {
+        try {
+            const raw = await fsPromises.readFile(filePath, "utf-8");
+            try {
+                const parsed = JSON.parse(raw);
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                    return null;
+                }
+                return parsed;
+            }
+            catch {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeJson(filePath, data) {
+        const notes = Object.fromEntries(Object.entries(data.notes).map(([key, note]) => [
+            key,
+            {
+                ...note,
+                value: (0, cap_string_1.capStructuredRecordString)(note.value),
+            },
+        ]));
+        await fsPromises.writeFile(filePath, JSON.stringify({ ...data, notes }, null, 2), "utf-8");
+    }
+    async removeFile(filePath) {
+        try {
+            await fsPromises.unlink(filePath);
+        }
+        catch (err) {
+            if (err?.code === "ENOENT")
+                return;
+            throw err;
+        }
+    }
+}
+exports.FileFriendStore = FileFriendStore;

package/dist/store.d.ts

@@ -0,0 +1,9 @@
+import type { FriendRecord } from "./types";
+export interface FriendStore {
+    get(id: string): Promise<FriendRecord | null>;
+    put(id: string, record: FriendRecord): Promise<void>;
+    delete(id: string): Promise<void>;
+    findByExternalId(provider: string, externalId: string, tenantId?: string): Promise<FriendRecord | null>;
+    hasAnyFriends?(): Promise<boolean>;
+    listAll?(): Promise<FriendRecord[]>;
+}

package/dist/store.js

@@ -0,0 +1,4 @@
+"use strict";
+// Friend store abstraction.
+// All friend persistence goes through FriendStore -- no friend module imports `fs` directly.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tokens.d.ts

@@ -0,0 +1,8 @@
+import type { FriendStore } from "./store";
+export interface UsageData {
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    total_tokens: number;
+}
+export declare function accumulateFriendTokens(store: FriendStore, friendId: string, usage?: UsageData): Promise<void>;

package/dist/tokens.js

@@ -0,0 +1,26 @@
+"use strict";
+// Token accumulation helper.
+// Tracks cumulative token usage per friend across turns.
+// Called from both CLI and Teams adapters after each agent turn.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accumulateFriendTokens = accumulateFriendTokens;
+const observability_1 = require("./observability");
+async function accumulateFriendTokens(store, friendId, usage) {
+    if (!usage?.output_tokens)
+        return;
+    const record = await store.get(friendId);
+    if (!record)
+        return;
+    // Only count output tokens (what the model generated for this friend).
+    // Input tokens are mostly system prompt re-sent every turn -- counting them
+    // would inflate the total and make the onboarding threshold meaningless.
+    record.totalTokens = (record.totalTokens ?? 0) + usage.output_tokens;
+    record.updatedAt = new Date().toISOString();
+    await store.put(record.id, record);
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.tokens_accumulated",
+        message: "tokens accumulated for friend",
+        meta: { friendId, outputTokens: usage.output_tokens },
+    });
+}

package/dist/trust-explanation.d.ts

@@ -0,0 +1,16 @@
+import type { Channel, FriendRecord, TrustLevel } from "./types";
+export type TrustBasis = "direct" | "shared_group" | "unknown";
+export interface TrustExplanation {
+    level: TrustLevel;
+    basis: TrustBasis;
+    summary: string;
+    why: string;
+    permits: string[];
+    constraints: string[];
+    relatedGroupId?: string;
+}
+export declare function describeTrustContext(input: {
+    friend: FriendRecord;
+    channel: Channel;
+    isGroupChat?: boolean;
+}): TrustExplanation;

package/dist/trust-explanation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeTrustContext = describeTrustContext;
+const observability_1 = require("./observability");
+function findRelatedGroupId(friend) {
+    return friend.externalIds.find((externalId) => externalId.externalId.startsWith("group:"))?.externalId;
+}
+function resolveLevel(friend) {
+    return friend.trustLevel ?? "stranger";
+}
+function describeTrustContext(input) {
+    const level = resolveLevel(input.friend);
+    const relatedGroupId = findRelatedGroupId(input.friend);
+    const explanation = level === "family" || level === "friend"
+        ? {
+            level,
+            basis: "direct",
+            summary: level === "family"
+                ? "direct family trust"
+                : "direct trusted relationship",
+            why: "this relationship is directly trusted rather than inferred through a shared group or cold first contact.",
+            permits: [
+                "local operations when appropriate",
+                "proactive follow-through",
+                "full collaborative problem solving",
+            ],
+            constraints: [],
+        }
+        : level === "acquaintance"
+            ? {
+                level,
+                basis: "shared_group",
+                summary: relatedGroupId
+                    ? "known through the shared project group"
+                    : "known through a shared group context",
+                why: relatedGroupId
+                    ? `this trust comes from the shared group context ${relatedGroupId}, not from direct endorsement.`
+                    : "this trust comes from shared group context rather than direct endorsement.",
+                permits: [
+                    "group-safe coordination",
+                    "normal conversation inside the shared context",
+                ],
+                constraints: [
+                    "guarded local actions",
+                    "do not assume broad private authority",
+                ],
+                relatedGroupId,
+            }
+            : {
+                level,
+                basis: "unknown",
+                summary: "truly unknown first-contact context",
+                why: "this person is not known through direct trust or a shared group context.",
+                permits: [
+                    "safe first-contact orientation only",
+                ],
+                constraints: [
+                    "first contact does not reach the full model on open channels",
+                    "no local or privileged actions",
+                ],
+            };
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.trust_explained",
+        message: "built explicit trust explanation",
+        meta: {
+            channel: input.channel,
+            level: explanation.level,
+            basis: explanation.basis,
+            hasRelatedGroup: Boolean(explanation.relatedGroupId),
+        },
+    });
+    return explanation;
+}

package/dist/trust-mutation.d.ts

@@ -0,0 +1,4 @@
+import type { FriendStore } from "./store";
+import type { TrustLevel } from "./types";
+import type { FriendOpResult } from "./results";
+export declare function setFriendTrust(store: FriendStore, friendId: string, level: TrustLevel): Promise<FriendOpResult>;

package/dist/trust-mutation.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFriendTrust = setFriendTrust;
+// setFriendTrust — structured-result port of the harness's `friend.update`.
+//
+// Sets a friend's trust level. Mirrors the harness behavior of writing BOTH
+// `trustLevel` and `role` to the same level (so the record's coarse role tracks
+// its trust). A missing friend is a normal `not_found` result, never a throw.
+const observability_1 = require("./observability");
+async function setFriendTrust(store, friendId, level) {
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.trust_set",
+        message: "set friend trust",
+        meta: { level },
+    });
+    const current = await store.get(friendId);
+    if (!current) {
+        return { ok: false, status: "not_found", message: "friend record not found" };
+    }
+    const updated = {
+        ...current,
+        trustLevel: level,
+        role: level,
+        updatedAt: new Date().toISOString(),
+    };
+    await store.put(friendId, updated);
+    return { ok: true, status: "updated", record: updated };
+}

package/dist/types.d.ts

@@ -0,0 +1,164 @@
+export type IdentityProvider = "aad" | "local" | "teams-conversation" | "imessage-handle" | "email-address" | "a2a-agent";
+export declare function isIdentityProvider(value: unknown): value is IdentityProvider;
+export type Channel = "cli" | "teams" | "bluebubbles" | "mail" | "voice" | "a2a" | "inner" | "mcp";
+export type Integration = "ado" | "github" | "graph";
+export declare function isIntegration(value: unknown): value is Integration;
+export interface ExternalId {
+    provider: IdentityProvider;
+    externalId: string;
+    tenantId?: string;
+    linkedAt: string;
+}
+export type TrustLevel = "family" | "friend" | "acquaintance" | "stranger";
+/** Trust levels that grant full tool access and proactive send capability. */
+export declare const TRUSTED_LEVELS: ReadonlySet<TrustLevel>;
+/** Whether a trust level grants full access (family or friend). Defaults to "friend" for legacy records. */
+export declare function isTrustedLevel(trustLevel?: TrustLevel): boolean;
+export interface FriendConnection {
+    name: string;
+    relationship: string;
+}
+export interface AgentAttribution {
+    agentId?: string;
+    agentName?: string;
+}
+export interface NoteProvenance {
+    assertedBy?: AgentAttribution;
+    /** Provenance origin. Absent ⇒ treat as "first_party". An "imported" fact came
+     * from another agent's share and must never be laundered into first-party. */
+    origin?: "first_party" | "imported";
+    /** ISO timestamp at which an imported fact was accepted. Set only on imports. */
+    importedAt?: string;
+}
+export interface ImportedNote {
+    value: string;
+    importedAt: string;
+    assertedBy?: AgentAttribution;
+    originallyAssertedBy?: AgentAttribution;
+}
+export type ShareScope = "name" | "identity" | "notes:safe" | "notes:all" | "outcomes" | "mission" | "coordinate";
+export declare function isShareScope(value: unknown): value is ShareScope;
+/** Identity-only scopes expose the join key (externalIds + name), never note
+ * content. The tiered consent policy gates these on trust alone. `coordinate`
+ * (brick 5) joins them: a coordination message names a mission by its join key
+ * and carries no note content, so trust ≥ friend consents to it — a friend peer
+ * may be asked to take a mission without a per-mission content grant. */
+export declare const IDENTITY_SCOPES: ReadonlySet<ShareScope>;
+export interface ShareGrant {
+    id: string;
+    subjectKey: string;
+    recipientAgentId: string;
+    scope: ShareScope;
+    grantedAt: string;
+    /** Optional ISO expiry. A grant past its expiry no longer consents. */
+    expiresAt?: string;
+    /** Set when the grant has been revoked. A revoked grant no longer consents. */
+    revokedAt?: string;
+}
+export interface RelationshipOutcome {
+    missionId: string;
+    result: "success" | "partial" | "failed";
+    timestamp: string;
+    note?: string;
+    provenance?: NoteProvenance;
+}
+export type MissionKey = string;
+export interface MissionLearning {
+    value: string;
+    savedAt: string;
+    provenance?: NoteProvenance;
+    shareable?: boolean;
+}
+export interface ImportedLearning {
+    value: string;
+    importedAt: string;
+    assertedBy?: AgentAttribution;
+    originallyAssertedBy?: AgentAttribution;
+}
+export type CoordinationIntent = "request" | "offer" | "accept" | "decline" | "handoff";
+export declare function isCoordinationIntent(value: unknown): value is CoordinationIntent;
+export interface CoordinationLogEntry {
+    intent: CoordinationIntent;
+    fromAgentId: string;
+    note?: string;
+    at: string;
+    provenance?: NoteProvenance;
+}
+export interface MissionCoordination {
+    assignee?: AgentAttribution;
+    assignedAt?: string;
+    log: CoordinationLogEntry[];
+}
+export interface MissionRecord {
+    id: string;
+    missionKey: MissionKey;
+    title: string;
+    status: "active" | "succeeded" | "partial" | "failed" | "abandoned";
+    participants: AgentAttribution[];
+    outcomes: RelationshipOutcome[];
+    learnings: Record<string, MissionLearning>;
+    importedLearnings?: Record<string, Record<string, ImportedLearning>>;
+    coordination?: MissionCoordination;
+    createdAt: string;
+    updatedAt: string;
+    schemaVersion: number;
+}
+export interface AgentMeta {
+    bundleName: string;
+    familiarity: number;
+    sharedMissions: string[];
+    outcomes: RelationshipOutcome[];
+    a2a?: {
+        cardUrl?: string;
+        endpointUrl?: string;
+        agentId?: string;
+        protocolVersion?: string;
+        /** Optional A2A git-mailbox coordinates (brick two). The mailbox is a
+         * dedicated PRIVATE repo holding only in-flight envelopes; `selfOutboxAgentId`
+         * is the dir THIS peer writes its outbox under. Absent on records that don't
+         * use the git-mailbox transport. */
+        mailbox?: {
+            repo: string;
+            selfOutboxAgentId: string;
+        };
+    };
+}
+export interface FriendRecord {
+    id: string;
+    name: string;
+    role?: string;
+    trustLevel?: TrustLevel;
+    connections?: FriendConnection[];
+    externalIds: ExternalId[];
+    tenantMemberships: string[];
+    toolPreferences: Record<string, string>;
+    notes: Record<string, {
+        value: string;
+        savedAt: string;
+        provenance?: NoteProvenance;
+        shareable?: boolean;
+    }>;
+    importedNotes?: Record<string, Record<string, ImportedNote>>;
+    totalTokens: number;
+    createdAt: string;
+    updatedAt: string;
+    schemaVersion: number;
+    kind?: "human" | "agent";
+    agentMeta?: AgentMeta;
+}
+export type SenseType = "open" | "closed" | "local" | "internal";
+export interface ChannelCapabilities {
+    channel: Channel;
+    senseType: SenseType;
+    availableIntegrations: Integration[];
+    supportsMarkdown: boolean;
+    supportsStreaming: boolean;
+    supportsRichCards: boolean;
+    maxMessageLength: number;
+}
+export interface ResolvedContext {
+    readonly friend: FriendRecord;
+    readonly channel: ChannelCapabilities;
+    /** Whether the current conversation is a group chat (vs 1:1). Default false. */
+    readonly isGroupChat?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,51 @@
+"use strict";
+// Context kernel type definitions.
+// FriendRecord (merged identity + notes), channel capabilities, and resolved context.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDENTITY_SCOPES = exports.TRUSTED_LEVELS = void 0;
+exports.isIdentityProvider = isIdentityProvider;
+exports.isIntegration = isIntegration;
+exports.isTrustedLevel = isTrustedLevel;
+exports.isShareScope = isShareScope;
+exports.isCoordinationIntent = isCoordinationIntent;
+const observability_1 = require("./observability");
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle", "email-address", "a2a-agent"]);
+function isIdentityProvider(value) {
+    (0, observability_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.identity_provider_check",
+        message: "identity provider validation",
+        meta: {},
+    });
+    return typeof value === "string" && IDENTITY_PROVIDERS.has(value);
+}
+const INTEGRATIONS = new Set(["ado", "github", "graph"]);
+function isIntegration(value) {
+    return typeof value === "string" && INTEGRATIONS.has(value);
+}
+/** Trust levels that grant full tool access and proactive send capability. */
+exports.TRUSTED_LEVELS = new Set(["family", "friend"]);
+/** Whether a trust level grants full access (family or friend). Defaults to "friend" for legacy records. */
+function isTrustedLevel(trustLevel) {
+    return exports.TRUSTED_LEVELS.has(trustLevel ?? "friend");
+}
+const SHARE_SCOPES = new Set(["name", "identity", "notes:safe", "notes:all", "outcomes", "mission", "coordinate"]);
+function isShareScope(value) {
+    return typeof value === "string" && SHARE_SCOPES.has(value);
+}
+/** Identity-only scopes expose the join key (externalIds + name), never note
+ * content. The tiered consent policy gates these on trust alone. `coordinate`
+ * (brick 5) joins them: a coordination message names a mission by its join key
+ * and carries no note content, so trust ≥ friend consents to it — a friend peer
+ * may be asked to take a mission without a per-mission content grant. */
+exports.IDENTITY_SCOPES = new Set(["name", "identity", "coordinate"]);
+const COORDINATION_INTENTS = new Set([
+    "request",
+    "offer",
+    "accept",
+    "decline",
+    "handoff",
+]);
+function isCoordinationIntent(value) {
+    return typeof value === "string" && COORDINATION_INTENTS.has(value);
+}

package/dist/util/cap-string.d.ts

@@ -0,0 +1,7 @@
+export declare const EVENT_CONTENT_MAX_CHARS: number;
+export declare function truncateLargeEventContent(content: unknown, maxChars: number): {
+    content: unknown;
+    truncated: boolean;
+    originalLength: number;
+};
+export declare function capStructuredRecordString(value: string): string;