@rine-network/eve 0.3.0 → 0.5.0

package/README.md

@@ -8,8 +8,8 @@ It does two things for an Eve agent:
 
 - **Reachability — a rine channel.** Other agents (across orgs) can message your
   Eve agent over rine; inbound messages start or resume a durable session and the
-  agent's reply is encrypted and delivered back automatically. Your agent becomes a
-  first-class citizen of the rine network while it also lives on Slack/Discord/etc.
+  agent's reply is encrypted and delivered back automatically. Your agent is
+  addressable on the rine network while it also lives on Slack/Discord/etc.
 - **Agency — rine tools.** File-discovered `rine_*` tools let the agent send,
   discover, and coordinate in groups on its own.
 
@@ -96,13 +96,19 @@ undecryptable mail is dropped by default.
 
 | Tool | Purpose |
 |------|---------|
-| `rine_send` | Send a 1:1 (`name@org`) or group (`#group@org`) E2EE message |
+| `rine_send` | Send a 1:1 (`kofi@acme.rine.network`) or group E2EE message. A group is named `#logistics@acme.rine.network`, by its own name, or by UUID |
 | `rine_send_and_wait` | 1:1 send that blocks for a reply |
-| `rine_check_inbox` / `rine_read` | Pull / read decrypted mail |
+| `rine_inbox` / `rine_read` | Pull / read decrypted mail. `rine_inbox` takes a `status` (`new` default, `delivered`, `read`, `all`); only `new` marks what it returns delivered |
 | `rine_reply` | Reply to a message by id, in-thread |
-| `rine_thread` | Decrypted both-sided transcript of a conversation |
+| `rine_thread` | Decrypted both-sided transcript of a conversation or a group. Name `group` (handle, name or UUID) or `conversationId` — exactly one of the two. A group's transcript starts where the reading agent was seated |
 | `rine_discover` / `rine_inspect` | Search the directory / read a profile |
-| `rine_group_create` / `_invite` / `_remove` / `_inspect` / `_join` / `_invites` | MLS-by-default groups |
+| `rine_whoami` | This agent's own org, trust tier, and live handles |
+| `rine_groups` / `rine_discover_groups` | The groups your org's agents are in / the public group directory across every org (listed groups only, never their members). `rine_groups` is org-scoped, and each row's `your agents` clause names by handle which of your org's agents are seated in that group: look for the acting agent's own handle there before posting, because an empty clause means none of them is and a send into that group would be refused. To read what has been said in the group since this agent joined, name the group to `rine_thread` — its handle or its id; each `rine_groups` row's `conversation_id` works too, and a group nobody has posted in yet has none |
+| `rine_group_create` / `_invite` / `_remove` / `_inspect` / `_roster` / `_join` / `_invites` | MLS-by-default groups. A founding roster on create invites under every enrollment policy; a later `_invite` mints an invitation on a closed group and **nominates** on a majority or unanimity one, where the electorate decides. `_create`'s `voteDurationHours` (1-72, default 72) sets how long such a vote stays open; `description` is server-visible house rules, NOT end-to-end encrypted. `_inspect` says what kind of group it is, `_roster` says who is in it and marks your own org's members `(yours)` without hiding anybody else's, and `_invites` lists invitations and nominations addressed to this agent, told apart by status |
+| `rine_group_requests` / `_vote` | The outstanding admissions of a group, and the vote that decides one — by the members it had when it was filed who are still in it. Denials refuse it on that same electorate, so both bars fall as members leave |
+| `rine_group_leave` | Leave a group, retiring this host's key material for it |
+| `rine_group_sync` | Catch this host's MLS state up with a group it fell behind |
+| `rine_group_reclaim` | Seat the unseated, then retire the ratchet-tree leaves no member and no live invitation accounts for |
 | `rine_pay` | Pay a received `rine.v1.x402_payment_required` quote under the local spend policy |
 | `rine_fulfill` | Payee side: verify + settle a received payment and reply with a receipt |
 

package/dist/{channel-WlN3x1wP.js → channel-B81UiHyr.js}

@@ -1,6 +1,6 @@
-import { b as verifiedNote, m as renderMessageBody, n as asRecipient, v as renderThreadLine, y as senderLabel } from "./tool-xlLdY8kn.js";
+import { _ as renderThreadLine, b as verifiedNote, n as asRecipient, p as renderMessageBody, y as senderLabel } from "./tool-DeOeMNlK.js";
 import { n as verifyRineSignature } from "./hmac-CoaKHmf6.js";
-import { t as getRineClient } from "./client-DsG2xtKs.js";
+import { n as getRineClient, t as actingAgent } from "./client-CXJATA-m.js";
 import { POST, defineChannel } from "eve/channels";
 import { X402Error, X402_MESSAGE_TYPE, asMessageUuid } from "@rine-network/sdk";
 //#region src/transcript.ts
@@ -260,12 +260,15 @@ async function handleX402Inbound(deps, msg, messageId) {
 *     → `client.read(id)` to HPKE-decrypt + verify the sender's Ed25519 signature
 *     (content auth) → loop-guard → mark delivered → start/resume the session.
 *
-* TRUST NOTE: `verified === true` cryptographically binds the message's *signer*
-* (the envelope `kid`), but the SDK exposes only the server-asserted
-* `sender_handle` / `from_agent_id` for routing + display. A malicious relay could
-* misroute a reply (never read it — replies stay E2EE). Binding routing to the
-* verified signer needs an SDK change to surface `senderKid`; tracked as a
-* follow-up. Matches the sibling rine connectors' behavior.
+* TRUST NOTE: `verified === true` means the envelope signature checked out AND the
+* signing key it names belongs to the agent the server authenticated as the sender.
+* The `from_agent_id` this module routes and displays therefore IS the signer: a
+* peer cannot re-seal another agent's signed content and have it render here as
+* verified content of its own. Two limits remain. `sender_handle` is the server's
+* rendering of that agent id, so routing stays on the id. And the signature covers
+* the payload only — not this recipient, and no nonce — so an agent re-sending
+* content it signed earlier produces a copy that verifies as its own; the message
+* `id` is the de-duplication key (what the dedupe step above uses).
 */
 /** The line of context handed to the model so it knows who/where the message is from. */
 function senderContextLine(msg) {
@@ -418,7 +421,7 @@ function rineChannel(opts = {}) {
 	const autoPay = opts.payments?.autoPay ?? envFlag(process.env.RINE_X402_AUTO_PAY);
 	const seen = /* @__PURE__ */ new Set();
 	const client = () => opts.client ?? getRineClient({
-		agent: opts.agent ?? process.env.RINE_AGENT,
+		agent: actingAgent(opts),
 		apiUrl: opts.apiUrl,
 		configDir: opts.configDir
 	});

package/dist/channel-core.d.ts

@@ -8,12 +8,15 @@
  *     → `client.read(id)` to HPKE-decrypt + verify the sender's Ed25519 signature
  *     (content auth) → loop-guard → mark delivered → start/resume the session.
  *
- * TRUST NOTE: `verified === true` cryptographically binds the message's *signer*
- * (the envelope `kid`), but the SDK exposes only the server-asserted
- * `sender_handle` / `from_agent_id` for routing + display. A malicious relay could
- * misroute a reply (never read it — replies stay E2EE). Binding routing to the
- * verified signer needs an SDK change to surface `senderKid`; tracked as a
- * follow-up. Matches the sibling rine connectors' behavior.
+ * TRUST NOTE: `verified === true` means the envelope signature checked out AND the
+ * signing key it names belongs to the agent the server authenticated as the sender.
+ * The `from_agent_id` this module routes and displays therefore IS the signer: a
+ * peer cannot re-seal another agent's signed content and have it render here as
+ * verified content of its own. Two limits remain. `sender_handle` is the server's
+ * rendering of that agent id, so routing stays on the id. And the signature covers
+ * the payload only — not this recipient, and no nonce — so an agent re-sending
+ * content it signed earlier produces a copy that verifies as its own; the message
+ * `id` is the de-duplication key (what the dedupe step above uses).
  */
 import type { AsyncRineClient } from "@rine-network/sdk";
 import type { DecryptedMessage } from "./types.js";

package/dist/channel.d.ts

@@ -27,7 +27,7 @@ export type { CompletionDeps } from "./channel-outbound.js";
 export declare const DEFAULT_IGNORE_TYPES: string[];
 /** Options for {@link rineChannel}. All optional; identity defaults to env. */
 export interface RineChannelOptions {
-    /** Acting agent (handle/name/UUID); defaults to `process.env.RINE_AGENT`. */
+    /** Acting agent (handle/name/UUID); falls back to the `RINE_AGENT` env var. */
     agent?: string;
     apiUrl?: string;
     configDir?: string;

package/dist/channel.js

@@ -1,2 +1,2 @@
-import { a as processInbound, i as processFailure, n as rineChannel, o as senderContextLine, r as processCompletion, t as DEFAULT_IGNORE_TYPES } from "./channel-WlN3x1wP.js";
+import { a as processInbound, i as processFailure, n as rineChannel, o as senderContextLine, r as processCompletion, t as DEFAULT_IGNORE_TYPES } from "./channel-B81UiHyr.js";
 export { DEFAULT_IGNORE_TYPES, processCompletion, processFailure, processInbound, rineChannel, senderContextLine };

package/dist/{client-DsG2xtKs.js → client-CXJATA-m.js}

@@ -1,5 +1,5 @@
 import { AsyncRineClient } from "@rine-network/sdk";
-import { resolveApiUrl, resolveConfigDir } from "@rine-network/core";
+import { actorFromEnv, normalizeActor, resolveApiUrl, resolveConfigDir } from "@rine-network/core";
 //#region src/client.ts
 /**
 * Lazy `AsyncRineClient` construction (side-effect-free import).
@@ -17,6 +17,26 @@ import { resolveApiUrl, resolveConfigDir } from "@rine-network/core";
 *     `resolveConfigDir()` (env `RINE_CONFIG_DIR` → `~/.config/rine` → cwd/.rine).
 *   - the SDK ignores `RINE_API_URL`; we resolve `apiUrl` via `resolveApiUrl()`.
 */
+/**
+* Rungs 1–3 of the acting-agent ladder, for every rine surface Eve ships: the
+* caller's own value, then `RINE_AGENT`. Returns `undefined` when neither
+* answers, leaving the later rungs (the org's only agent, then a refusal) to
+* whoever needs a resolved id.
+*
+* 🔴 Deliberately NOT folded into {@link getRineClient}. The environment read is
+* a *surface* decision — `rine-ts-sdk` reads no environment at all, because
+* `rine-mastra` builds a bare client for an operator-fixed actor and would
+* inherit anything ambient the SDK picked up. Eve is a surface and opts in here,
+* once, so the four call sites cannot drift apart. Reading it inside
+* `getRineClient` would also make the memoized bare client env-dependent.
+*
+* `normalizeActor` trims and treats empty-after-trim as absent, which is what
+* makes the bare `RINE_AGENT=` line `scaffold.ts` writes into every generated
+* project mean "no actor set" rather than an actor named "".
+*/
+function actingAgent(opts = {}) {
+	return normalizeActor(opts.agent) ?? actorFromEnv();
+}
 const clientCache = /* @__PURE__ */ new Map();
 function cacheKey(configDir, apiUrl) {
 	return `${configDir} ${apiUrl}`;
@@ -41,4 +61,4 @@ function getRineClient(opts = {}) {
 	return opts.agent ? base.withAgent(opts.agent) : base;
 }
 //#endregion
-export { getRineClient as t };
+export { getRineClient as n, actingAgent as t };

package/dist/client.d.ts

@@ -24,6 +24,24 @@ export interface RineClientOpts {
     /** Acting agent (handle/name/UUID) sent as `X-Rine-Agent` on every request. */
     agent?: string;
 }
+/**
+ * Rungs 1–3 of the acting-agent ladder, for every rine surface Eve ships: the
+ * caller's own value, then `RINE_AGENT`. Returns `undefined` when neither
+ * answers, leaving the later rungs (the org's only agent, then a refusal) to
+ * whoever needs a resolved id.
+ *
+ * 🔴 Deliberately NOT folded into {@link getRineClient}. The environment read is
+ * a *surface* decision — `rine-ts-sdk` reads no environment at all, because
+ * `rine-mastra` builds a bare client for an operator-fixed actor and would
+ * inherit anything ambient the SDK picked up. Eve is a surface and opts in here,
+ * once, so the four call sites cannot drift apart. Reading it inside
+ * `getRineClient` would also make the memoized bare client env-dependent.
+ *
+ * `normalizeActor` trims and treats empty-after-trim as absent, which is what
+ * makes the bare `RINE_AGENT=` line `scaffold.ts` writes into every generated
+ * project mean "no actor set" rather than an actor named "".
+ */
+export declare function actingAgent(opts?: Pick<RineClientOpts, "agent">): string | undefined;
 /**
  * Get (or lazily build + memoize) the shared `AsyncRineClient` for `opts`,
  * already scoped to `opts.agent` when present. Call ONLY from inside a tool

package/dist/format-groups-list.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The plural group renderers: the caller's own groups, a directory search, and
+ * one group's roster. `format.ts`'s `renderGroup` renders exactly ONE group and
+ * is what `rine_group_inspect` returns; these render pages, one numbered row
+ * each, in the shape `renderInbox`/`renderDiscover` already use.
+ *
+ * A sibling of `format.ts` rather than part of it, for the same reason
+ * `format-groups.ts` is one — `format.ts` holds its ~200-LOC budget.
+ *
+ * The types come from `@rine-network/sdk` directly: the SDK exports them
+ * alongside their schemas, so there is nothing here to re-derive.
+ */
+import { type AgentHandleMap, type GroupMember, type GroupRead, type GroupSummary } from "@rine-network/sdk";
+/**
+ * What a group with no conversation renders instead of an id.
+ *
+ * A group's thread is created lazily on its first post, so a null
+ * `conversation_id` is the fact "nothing has been said in this group yet" — not
+ * an error, not a refusal, and not a missing field. The clause is never omitted
+ * on null: a model that sees it on some rows and not others reads the absence
+ * as a rendering fault rather than as a fact about the group.
+ *
+ * `format.ts`'s `renderGroup` imports it from here so the two renderers cannot
+ * tell a model two different things about the same group. The same sentence is
+ * printed by the CLI, crewai, langchain, hermes and mastra; it is restated per
+ * package because there is no runtime module all of them import.
+ */
+export declare const NO_CONVERSATION = "(none \u2014 nothing has been said in this group yet)";
+/**
+ * What a group renders in place of an agent list when this org holds no seat.
+ *
+ * The group list is ORG-scoped — it reports every group any agent of this org
+ * is in — so a row on it was never proof that the agent this host is acting as
+ * may post there. The empty list is that proof's absence stated plainly: no
+ * agent of this org is seated, and a send into the group would be refused.
+ *
+ * Never omitted, for the reason `NO_CONVERSATION` gives above: a clause a model
+ * sees on some rows and not others reads as a rendering fault rather than as a
+ * fact about the group. Restated per package because there is no runtime module
+ * all seven rendering surfaces import — though this package and its twin do
+ * share one (`@rine-network/sdk`), so the day either reworded its row would be
+ * the day the sentence belongs there instead.
+ *
+ * Pinned meanwhile: `tests/test_client-server-contract_group0.py` compares the
+ * four declared copies against `rine.group_words.NO_OWN_AGENTS`, which the
+ * three Python surfaces import, so a reword in one package fails there rather
+ * than shipping two answers to one question.
+ */
+export declare const NO_OWN_AGENTS = "(none \u2014 no agent of your org is seated in this group)";
+/**
+ * The seated-agents clause, from the one place both renderers read it.
+ *
+ * `format.ts`'s `renderGroup` calls this too, so the row and the single-group
+ * view cannot tell a model two different things about the same group — the same
+ * reason `NO_CONVERSATION` is imported there rather than retyped.
+ *
+ * Each id renders as its HANDLE. The three cases, and why a name is never one
+ * of them, are stated once on `AgentHandleMap` in the SDK
+ * (`rine-ts-sdk/src/resources/agent-handles.ts`); this renderer is one of the
+ * four that follow them. In short: a known id prints its handle, an unknown one
+ * prints itself, an empty list prints {@link NO_OWN_AGENTS}. A model handed a
+ * UUID cannot tell which of its agents it names — that is the whole reason
+ * handle resolution exists here — but a UUID is still addressable, so an
+ * unresolved id is degraded, not lost.
+ *
+ * `handles` is omitted whenever the org's agent list could not be read; that is
+ * case 2 for every id, and it is why nothing here throws.
+ *
+ * `undefined` is accepted on purpose. `GroupReadSchema` defaults the field to
+ * `[]`, so a parsed row always has one — but a row that never went through that
+ * parse (a hand-built object, a fake) has nothing, and a renderer whose job is
+ * to state an absence must not throw on one.
+ */
+export declare function renderOwnAgents(ids: readonly string[] | undefined, handles?: AgentHandleMap): string;
+/**
+ * How this package names a group's regime in one field, for a LIST ROW.
+ *
+ * One definition for the row, and for the row only. It is NOT what the create
+ * confirmation head asks: what a freshly created group runs is decided from the
+ * create RESULT, by `createdGroupMls` in `@rine-network/core`, because the row
+ * alone cannot tell a founded group from an unfounded one. `renderGroup`'s
+ * `[OK]` line re-derives its first clause from the predicates directly and has
+ * never called this either. So a reword here reaches this row and nothing else,
+ * and a reword in either of those two does not reach this row.
+ *
+ * The init window is reported as MLS because sends into it already are MLS, and
+ * a field that said "sender-key" there would state the opposite of what is
+ * happening. The window's own distinction is `rine_group_inspect`'s to make.
+ *
+ * A group created to run MLS whose ratchet tree was never founded really does
+ * carry sender-key traffic, so it names sender keys — and says the rest of the
+ * answer, because that row is otherwise field-for-field an open group's and
+ * nothing else on the page can tell the two apart. The parenthesis carries NO
+ * comma: the row below is comma-separated, which is the same reason its last
+ * clause opens with `; `. The whole sentence lives in `rine_group_inspect`; a
+ * list row is not the place for it.
+ */
+export declare function groupModeLabel(g: GroupRead): string;
+/**
+ * A numbered list of the groups this org's agents are seated in, or the
+ * empty-state line.
+ *
+ * The list is org-scoped, and each row's `your agents` clause names which of
+ * this org's agents are seated in that group — an empty clause means none of
+ * them is, and a send into that group would be refused. The clause names them
+ * by handle because that is the spelling `rine_whoami` prints, so the two
+ * outputs can be read against each other — a UUID matched nothing this surface
+ * had ever shown the model. What neither tool says is which agent this host is
+ * acting AS: `WhoAmI` carries no such field and `renderWhoAmI` marks no row, so
+ * in a multi-agent org that still has to come from the host's own config (the
+ * `agent` this client was built with, which may itself have been given as a
+ * UUID).
+ */
+export declare function renderGroups(items: readonly GroupRead[], handles?: AgentHandleMap): string;
+/**
+ * A numbered list of publicly listed groups, or the empty-state line.
+ *
+ * The header says what the list IS. `GET /directory/groups` is an
+ * unauthenticated public-visibility scan across every org and carries no
+ * identity at all, so nothing on a row can say whether this agent holds a seat
+ * in that group — while `renderGroups` above prints near-identical rows that
+ * end with exactly that. Two numbered lists told apart by two words in a header
+ * is not enough, so this one says the difference outright.
+ *
+ * It names no verb: the header states what the caller is looking at, and which
+ * tool to reach for next is the tool description's sentence, not this one's.
+ */
+export declare function renderGroupSummaries(items: readonly GroupSummary[]): string;
+/**
+ * A numbered roster, or the empty-state line.
+ *
+ * The roster is members only. An invitation and a nomination hold a seat
+ * against the group's ceiling without appearing here — `rine_group_requests`
+ * is what reports those — so a roster shorter than the ceiling suggests is not
+ * a gap in this list.
+ *
+ * Every member is listed, from every org. Nothing here filters on whose agent
+ * a row is; `(yours)` marks this org's rows and takes none away.
+ */
+export declare function renderRoster(items: readonly GroupMember[]): string;

package/dist/format-groups.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The admission strings this package composes itself: the outstanding list
+ * `rine_group_requests` renders, the line `rine_group_vote` returns, the refusal
+ * a vote from outside the electorate reads as, and what `rine_group_reclaim`
+ * did to the ratchet tree.
+ *
+ * They sit beside `format.ts`'s group renderers rather than in the tool module,
+ * in a sibling of their own for the same reason `schemas-groups.ts` is one —
+ * `format.ts` holds its ~200-LOC budget. Their wording is fixed across every
+ * surface that ships these verbs, so a vote reads the same here, from the CLI,
+ * and from the Python connectors.
+ *
+ * Every other group verb returns a sentence composed once, further in: a removal
+ * and a leave return `result.message` from the SDK, a sync returns
+ * `describeMlsRecovery`, and the reclamation half below returns
+ * `describeMlsReclamation`. The rest have no such sentence to return.
+ */
+import { type MlsAdmissionResult } from "@rine-network/sdk";
+import type { JoinRequestRead, VoteResponse } from "./types.js";
+/**
+ * The outstanding admissions of one group under one filter, oldest first.
+ *
+ * Sorted here rather than trusted from the wire: the ordering is what every
+ * surface promises a voter, and the Python connectors sort too — so leaving it
+ * to the server would make the same list read differently by stack.
+ *
+ * `groupRef` is the reference the caller gave, not a UUID it never named.
+ */
+export declare function renderRequests(groupRef: string, outstanding: string, rows: readonly JoinRequestRead[]): string;
+/**
+ * The outcome of one vote.
+ *
+ * The leaf-and-Welcome sentence is conditioned on `mls_seated`, not on the
+ * server's `approved`. The seat the SDK attempts inside `vote()` is
+ * best-effort: a group running Sender Keys has no ratchet tree to mint a leaf
+ * in, and an add commit that fails is logged and swallowed so the vote can
+ * still be reported. On the status alone this claimed a Welcome for every vote
+ * that minted none — which is exactly the failure the seat exists to prevent,
+ * reported as a success.
+ *
+ * `invited` is the fourth answer a carried vote gives, and it is named rather
+ * than left to the bare status line. A member may nominate an agent into a
+ * `majority` or `unanimity` group, and the electorate can carry that nomination
+ * before the nominee has asked for anything; the request then resolves to a
+ * spendable invitation instead of a seat, so the agent that was never asked
+ * still decides for itself. Reporting it as "approved" would claim a membership
+ * that does not exist, and falling through to the bare line would leave a model
+ * reading a status word no other outcome uses.
+ */
+export declare function renderVote(groupRef: string, result: VoteResponse): string;
+/**
+ * A vote the electorate rule refused, as something the model can act on —
+ * or `undefined` for any other failure, which the shared `formatError` owns.
+ *
+ * Branching on the server's error CODE, never on its sentence: three 403s on
+ * this route mean different things, and the detail is written for an operator
+ * and is rewritten whenever the wording improves. `no vote was recorded` is
+ * stated first because that is the fact an agent would otherwise have to infer
+ * from a status code, and a retry of the same call cannot change any of them.
+ *
+ * There is deliberately no `BarUnreachable` arm. `bar_unreachable` and
+ * `electorate_empty` are one refusal and two facts about the row: the route
+ * raises `ElectorateEmptyError` for both, so an arm keyed on the other token
+ * could never run, and the `ElectorateEmpty` sentence is true of both cases.
+ * The two are told apart where they differ — on the row, by
+ * {@link renderRequests}.
+ */
+export declare function renderVoteRefusal(groupRef: string, err: unknown): string | undefined;
+/**
+ * What one reclamation pass seated and what it retired.
+ *
+ * The pass seats first and reclaims second, so the report carries both: a leaf
+ * belonging to an agent this run has just seated is not an orphan, and a
+ * reclamation reported without the seating that preceded it would read as
+ * though the tree had been trimmed against a roster nobody caught up.
+ *
+ * The reclamation half is `describeMlsReclamation` rather than a sentence of
+ * this package's own — one implementation for the four TypeScript surfaces that
+ * report a reclamation, sentence for sentence identical to the Python twin.
+ */
+export declare function renderReclamation(groupRef: string, result: MlsAdmissionResult): string;

package/dist/format.d.ts

@@ -6,7 +6,7 @@
  * fields. They NEVER read `encrypted_payload` or any envelope/ciphertext field,
  * so ciphertext can never reach the LLM context through a rendered string.
  */
-import type { ThreadEntry } from "@rine-network/sdk";
+import type { AgentHandleMap, SenderKeyExplainer, ThreadEntry, WhoAmI } from "@rine-network/sdk";
 import type { AgentProfile, AgentSummary, DecryptedMessage, GroupRead, JoinRequestRead, JoinResult } from "./types.js";
 /** One thread turn as a role-tagged line: `[sent] you: …` / `[received] alice@org: …`. */
 export declare function renderThreadLine(e: ThreadEntry): string;
@@ -26,29 +26,69 @@ export declare function verifiedNote(msg: DecryptedMessage): string;
  *   - anything else → compact JSON (last resort)
  */
 export declare function unwrapText(plaintext: unknown): string;
-/** Body of a message: decrypt error if unreadable, else the unwrapped plaintext. */
-export declare function renderMessageBody(msg: DecryptedMessage): string;
+/**
+ * Body of a message: decrypt error if unreadable, else the unwrapped plaintext.
+ *
+ * `explain` is the per-render tiering: pass it on a MULTI render (an inbox,
+ * one call per `renderInbox()`) so the no-sender-key cause explains itself in
+ * full on the first unreadable row and marks every subsequent one. Omit it on
+ * a SINGLE render (`rine_read`, a `rine_send_and_wait` reply, the webhook
+ * channel's own inbound render) so the one row keeps the full sentence it
+ * already carries — there is nothing to tier when the caller asked for
+ * exactly one message. Every other decrypt-error cause is untouched either
+ * way; classification is the typed `decrypt_error_code`, never the words in
+ * `decrypt_error`.
+ */
+export declare function renderMessageBody(msg: DecryptedMessage, explain?: SenderKeyExplainer): string;
 /** Sender label: prefer the human handle, fall back to the agent UUID. */
 export declare function senderLabel(msg: DecryptedMessage): string;
 /** A single message rendered across multiple labeled lines (for `rine_read`). */
 export declare function renderSingleMessage(msg: DecryptedMessage): string;
-/** A numbered inbox list, or the empty-state line. */
+/**
+ * A numbered inbox list, or the empty-state line.
+ *
+ * MULTI render: one explainer per `renderInbox()` call, so the
+ * no-sender-key cause explains itself once for this render and marks every
+ * later row with the same cause — never module-level, never per-row.
+ */
 export declare function renderInbox(items: readonly DecryptedMessage[]): string;
 /** A numbered discovery list, or the empty-state line. */
 export declare function renderDiscover(items: readonly AgentSummary[]): string;
 /** A full agent profile (for `rine_inspect`). */
 export declare function renderProfile(p: AgentProfile): string;
 /**
- * Self-diagnose a group's E2EE mode. Uses `mls_group_id !== null`, OR the
- * explicit `mls_enabled`/`mls_pending` flags. With MLS support present this is a
- * CAPABILITY flag, not a failure flag.
+ * This agent's own identity, for `rine_whoami`: the org it belongs to, the
+ * trust tier that org holds, and every handle it can act as.
+ *
+ * Revoked agents are dropped. The route returns them, and naming one here
+ * would offer the model a handle nothing can be sent from or to.
  */
-export declare function groupIsMls(g: GroupRead): boolean;
+export declare function renderWhoAmI(me: WhoAmI): string;
 /**
- * A group rendered for `rine_group_inspect`. Both the MLS and sender-key branches
- * are `[OK]` — an MLS group is readable/postable from here.
+ * A group rendered for `rine_group_inspect`. Every branch is `[OK]` — an MLS
+ * group is readable/postable from here.
+ *
+ * Four states, not two. The second is the MLS init window: the group has no
+ * `mls_group_id` to render yet, while the server already accepts nothing but
+ * MLS there, so sends from here are MLS sends. Rendering that window as either
+ * of the other states says the opposite of what is happening.
+ *
+ * The third is a group created to run MLS whose ratchet tree was never founded.
+ * It reads to every other question exactly like the fourth — an ordinary
+ * sender-key group — so it used to fall into it, and the agent was never told
+ * the group had not got the encryption it was created for. It stays `[OK]`:
+ * every claim that marker makes is true here, the group carries traffic, and
+ * only the regime is other than intended. The sentence is the SDK's, and this
+ * surface asks for the no-verb spelling because `rine_group_reclaim` refuses on
+ * eve — naming a verb that will not act is worse than naming none.
+ *
+ * `your agents` closes the gap the `[OK]` lines leave open: they describe how
+ * the GROUP is run, not whether this org may act in it. A group can be perfectly
+ * readable in the abstract and hold no seat of this org's at all. It names them
+ * by handle when `handles` resolves them — the rule is stated once on
+ * `AgentHandleMap` in the SDK, and `renderOwnAgents` is where it is applied.
  */
-export declare function renderGroup(g: GroupRead): string;
+export declare function renderGroup(g: GroupRead, handles?: AgentHandleMap): string;
 /** `rine_group_join` outcome: immediate membership vs a pending vote. */
 export declare function renderJoinResult(target: string, result: JoinResult): string;
 /** A numbered list of the caller's pending group invites, or the empty-state line. */

package/dist/index.js

@@ -1,10 +1,10 @@
-import { o as formatError } from "./tool-xlLdY8kn.js";
-import { a as processInbound, c as handleX402Inbound, d as x402GuidanceLine, f as decodeReplyToken, i as processFailure, l as isX402Frame, m as messageIdFromWebhook, n as rineChannel, o as senderContextLine, p as encodeReplyToken, r as processCompletion, s as X402_FRAME_TYPES, u as renderX402Body } from "./channel-WlN3x1wP.js";
+import { o as formatError } from "./tool-DeOeMNlK.js";
+import { a as processInbound, c as handleX402Inbound, d as x402GuidanceLine, f as decodeReplyToken, i as processFailure, l as isX402Frame, m as messageIdFromWebhook, n as rineChannel, o as senderContextLine, p as encodeReplyToken, r as processCompletion, s as X402_FRAME_TYPES, u as renderX402Body } from "./channel-B81UiHyr.js";
 import { n as verifyRineSignature, t as signRineBody } from "./hmac-CoaKHmf6.js";
-import { t as getRineClient } from "./client-DsG2xtKs.js";
-import { _ as rineInspectTool, a as rineReadTool, c as rineSendTool, d as rineGroupInspectTool, f as rineGroupInviteTool, g as rineDiscoverTool, h as rineGroupRemoveTool, i as rineCheckInboxTool, l as rineThreadTool, m as rineGroupJoinTool, n as rineFulfillTool, o as rineReplyTool, p as rineGroupInvitesTool, r as rinePayTool, s as rineSendAndWaitTool, t as RINE_TOOLS, u as rineGroupCreateTool } from "./tools-BhkhV3Mv.js";
-import { t as RINE_TOOL_META } from "./registry-Bn4EqPcp.js";
-import { a as toolFileContent, c as RINE_SKILL_FILE, i as scaffoldRine, n as envExampleBlock, o as RINE_SKILL_BODY, r as resolveToolSelection, s as RINE_SKILL_DESCRIPTION, t as channelFileContent } from "./scaffold-3cEUy3jD.js";
+import { n as getRineClient } from "./client-CXJATA-m.js";
+import { C as rineGroupVoteTool, E as rineWhoamiTool, S as rineGroupSyncTool, T as rineInspectTool, _ as rineGroupRosterTool, a as rineReadTool, b as rineGroupReclaimTool, c as rineSendTool, d as rineGroupInspectTool, f as rineGroupInviteTool, g as rineDiscoverGroupsTool, h as rineGroupRemoveTool, i as rineInboxTool, l as rineThreadTool, m as rineGroupJoinTool, n as rineFulfillTool, o as rineReplyTool, p as rineGroupInvitesTool, r as rinePayTool, s as rineSendAndWaitTool, t as RINE_TOOLS, u as rineGroupCreateTool, v as rineGroupsTool, w as rineDiscoverTool, x as rineGroupRequestsTool, y as rineGroupLeaveTool } from "./tools-CQDZG-qN.js";
+import { t as RINE_TOOL_META } from "./registry-DsU13KY3.js";
+import { a as toolFileContent, c as RINE_SKILL_FILE, i as scaffoldRine, n as envExampleBlock, o as RINE_SKILL_BODY, r as resolveToolSelection, s as RINE_SKILL_DESCRIPTION, t as channelFileContent } from "./scaffold-DQ2CA1kD.js";
 import { agentNameFromOrgName, parseOnboardArgs, runOnboard } from "./onboard.js";
 import { deleteRineWebhook, registerRineWebhook } from "./webhook.js";
 import { buildRelayBody, drainOnce, runRelay } from "./relay.js";
@@ -24,4 +24,4 @@ function rineSkill() {
 	});
 }
 //#endregion
-export { RINE_SKILL_BODY, RINE_SKILL_DESCRIPTION, RINE_SKILL_FILE, RINE_TOOLS, RINE_TOOL_META, X402_FRAME_TYPES, agentNameFromOrgName, buildRelayBody, channelFileContent, decodeReplyToken, deleteRineWebhook, drainOnce, encodeReplyToken, envExampleBlock, formatError, getRineClient, handleX402Inbound, isX402Frame, messageIdFromWebhook, parseOnboardArgs, processCompletion, processFailure, processInbound, registerRineWebhook, renderX402Body, resolveToolSelection, rineChannel, rineCheckInboxTool, rineDiscoverTool, rineFulfillTool, rineGroupCreateTool, rineGroupInspectTool, rineGroupInviteTool, rineGroupInvitesTool, rineGroupJoinTool, rineGroupRemoveTool, rineInspectTool, rinePayTool, rineReadTool, rineReplyTool, rineSendAndWaitTool, rineSendTool, rineSkill, rineThreadTool, runOnboard, runRelay, scaffoldRine, senderContextLine, signRineBody, toolFileContent, verifyRineSignature, x402GuidanceLine };
+export { RINE_SKILL_BODY, RINE_SKILL_DESCRIPTION, RINE_SKILL_FILE, RINE_TOOLS, RINE_TOOL_META, X402_FRAME_TYPES, agentNameFromOrgName, buildRelayBody, channelFileContent, decodeReplyToken, deleteRineWebhook, drainOnce, encodeReplyToken, envExampleBlock, formatError, getRineClient, handleX402Inbound, isX402Frame, messageIdFromWebhook, parseOnboardArgs, processCompletion, processFailure, processInbound, registerRineWebhook, renderX402Body, resolveToolSelection, rineChannel, rineDiscoverGroupsTool, rineDiscoverTool, rineFulfillTool, rineGroupCreateTool, rineGroupInspectTool, rineGroupInviteTool, rineGroupInvitesTool, rineGroupJoinTool, rineGroupLeaveTool, rineGroupReclaimTool, rineGroupRemoveTool, rineGroupRequestsTool, rineGroupRosterTool, rineGroupSyncTool, rineGroupVoteTool, rineGroupsTool, rineInboxTool, rineInspectTool, rinePayTool, rineReadTool, rineReplyTool, rineSendAndWaitTool, rineSendTool, rineSkill, rineThreadTool, rineWhoamiTool, runOnboard, runRelay, scaffoldRine, senderContextLine, signRineBody, toolFileContent, verifyRineSignature, x402GuidanceLine };

package/dist/onboard.js

@@ -1,5 +1,5 @@
 import { AsyncRineClient, register } from "@rine-network/sdk";
-import { resolveApiUrl, resolveConfigDir } from "@rine-network/core";
+import { compareVerificationWordsForAgent, resolveApiUrl, resolveConfigDir, verificationWordsLines } from "@rine-network/core";
 //#region src/onboard.ts
 /**
 * Setup helper — `npx @rine-network/eve onboard` (out-of-band, NEVER a tool).
@@ -54,7 +54,7 @@ async function runOnboard(opts, io = stdoutIO) {
 	const agent = await client.createAgent(agentName);
 	io.log("");
 	io.log(`Agent ready: ${agent.handle}`);
-	if (agent.verification_words) io.log(`Verification words: ${agent.verification_words}`);
+	for (const line of verificationWordsLines(compareVerificationWordsForAgent(configDir, agent.id, agent.verification_words))) io.log(line);
 	io.log(`Config dir: ${configDir}`);
 	io.log("Point your Eve agent at this identity: set RINE_CONFIG_DIR to the path above and RINE_AGENT to your handle.");
 	io.log("Next: deploy your agent, then `npx @rine-network/eve webhook --url https://<your-agent>.vercel.app` to receive inbound rine messages.");

package/dist/{registry-Bn4EqPcp.js → registry-DsU13KY3.js}

@@ -16,8 +16,8 @@ const RINE_TOOL_META = [
 		domain: "messaging"
 	},
 	{
-		name: "rine_check_inbox",
-		factoryName: "rineCheckInboxTool",
+		name: "rine_inbox",
+		factoryName: "rineInboxTool",
 		domain: "messaging"
 	},
 	{
@@ -45,6 +45,21 @@ const RINE_TOOL_META = [
 		factoryName: "rineInspectTool",
 		domain: "discovery"
 	},
+	{
+		name: "rine_discover_groups",
+		factoryName: "rineDiscoverGroupsTool",
+		domain: "discovery"
+	},
+	{
+		name: "rine_whoami",
+		factoryName: "rineWhoamiTool",
+		domain: "discovery"
+	},
+	{
+		name: "rine_groups",
+		factoryName: "rineGroupsTool",
+		domain: "groups"
+	},
 	{
 		name: "rine_group_create",
 		factoryName: "rineGroupCreateTool",
@@ -65,6 +80,11 @@ const RINE_TOOL_META = [
 		factoryName: "rineGroupInspectTool",
 		domain: "groups"
 	},
+	{
+		name: "rine_group_roster",
+		factoryName: "rineGroupRosterTool",
+		domain: "groups"
+	},
 	{
 		name: "rine_group_join",
 		factoryName: "rineGroupJoinTool",
@@ -75,6 +95,31 @@ const RINE_TOOL_META = [
 		factoryName: "rineGroupInvitesTool",
 		domain: "groups"
 	},
+	{
+		name: "rine_group_requests",
+		factoryName: "rineGroupRequestsTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_vote",
+		factoryName: "rineGroupVoteTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_leave",
+		factoryName: "rineGroupLeaveTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_sync",
+		factoryName: "rineGroupSyncTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_reclaim",
+		factoryName: "rineGroupReclaimTool",
+		domain: "groups"
+	},
 	{
 		name: "rine_pay",
 		factoryName: "rinePayTool",

package/dist/relay.js

@@ -1,5 +1,5 @@
 import { t as signRineBody } from "./hmac-CoaKHmf6.js";
-import { t as getRineClient } from "./client-DsG2xtKs.js";
+import { n as getRineClient, t as actingAgent } from "./client-CXJATA-m.js";
 import { resolveApiUrl } from "@rine-network/core";
 //#region src/relay.ts
 /**
@@ -81,7 +81,7 @@ async function runRelay(opts = {}) {
 	const wanted = opts.intervalMs;
 	const interval = Math.max(500, typeof wanted === "number" && Number.isFinite(wanted) && wanted > 0 ? wanted : DEFAULT_INTERVAL_MS);
 	const client = getRineClient({
-		agent: opts.agent ?? process.env.RINE_AGENT,
+		agent: actingAgent(opts),
 		apiUrl: opts.apiUrl,
 		configDir: opts.configDir
 	});