@rine-network/eve 0.2.0 → 0.5.0

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

@@ -2,12 +2,12 @@
  * Pure render functions: turn SDK return values into the human-readable strings
  * tools + the channel hand to the LLM / send back over rine.
  *
- * Invariant R4: these read ONLY `plaintext` / `decrypt_error` / verification
+ * These read ONLY `plaintext` / `decrypt_error` / verification
  * 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 { AgentProfile, AgentSummary, DecryptedMessage, GroupRead } from "./types.js";
+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,26 +26,70 @@ 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 (R9).
+ * 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 (R9).
+ * 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. */
+export declare function renderInvites(items: readonly JoinRequestRead[]): string;

package/dist/inbound.d.ts

@@ -2,14 +2,14 @@
  * Inbound webhook helpers for the rine channel: extracting the message id from a
  * rine standard-webhook body, and the continuation-token codec.
  *
- * The continuation token is how the channel makes outbound replies STATELESS (R7):
+ * The continuation token is how the channel makes outbound replies STATELESS:
  * it encodes the rine `conversation_id`, the reply target (the group handle for
  * group mail, else the sender handle), and — for 1:1 inbound only — the inbound
  * `message id` so the `message.completed` handler can reply IN-PLACE (via the reply
  * endpoint, preserving the inbound conversation) without any durable per-session map.
  * Because the token bakes in the per-message `m`, it differs on every 1:1 inbound
  * turn, so Eve does NOT resume a prior session from it — cross-turn continuity comes
- * from the general thread primitive (push-injected transcript, Slice E), not session
+ * from the general thread primitive (push-injected transcript), not session
  * resume. The message id is optional: group inbound and tokens minted by an older
  * build carry only `{c,r}` and decode with `messageId === undefined`, so the outbound
  * handler falls back to the `send()+parentConversationId` broadcast path.
@@ -35,7 +35,7 @@ export interface ReplyContext {
      */
     readonly messageId?: string;
     /**
-     * Marks a session started by an inbound x402 payment frame (D1). The terminal
+     * Marks a session started by an inbound x402 payment frame. The terminal
      * assistant message is NEVER prose-replied into a payment thread — that would
      * corrupt the handshake. The signed payment / receipt is transmitted in-thread
      * by the pay / fulfill tools instead, so `processCompletion` short-circuits when

package/dist/index.d.ts

@@ -6,7 +6,7 @@
  * reachability + outbound replies, file-discovered rine **tools** for agency, a
  * **skill**, and an out-of-band **onboard / init / webhook / relay** CLI.
  *
- * Import is side-effect-free (R1): nothing here builds a client, reads a
+ * Import is side-effect-free: nothing here builds a client, reads a
  * credential, or opens a socket at module load.
  *
  * Most consumers don't import from here — they run `npx @rine-network/eve init`,

package/dist/index.js

@@ -1,10 +1,10 @@
-import { o as formatError } from "./tool-BC49DldZ.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-b0iIAZTh.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-X_-9CpQT.js";
-import { a as rineReadTool, c as rineSendTool, d as rineGroupInspectTool, f as rineGroupInviteTool, h as rineInspectTool, i as rineCheckInboxTool, l as rineThreadTool, m as rineDiscoverTool, n as rineFulfillTool, o as rineReplyTool, p as rineGroupRemoveTool, r as rinePayTool, s as rineSendAndWaitTool, t as RINE_TOOLS, u as rineGroupCreateTool } from "./tools-BcVm_Onx.js";
-import { t as RINE_TOOL_META } from "./registry-6sWyhOyF.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-0luQyBRK.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, 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.d.ts

@@ -5,7 +5,7 @@
  * creates the first agent and prints its handle + verification words. A ~30–60 s
  * PoW does not belong in an LLM turn; it is a one-time CLI a human runs.
  *
- * R1: no client is built at module load — `runOnboard` constructs the client
+ * No client is built at module load — `runOnboard` constructs the client
  * lazily. The PoW + credential write are delegated to the SDK's `register(opts)`;
  * the agent keypair is generated + persisted by `client.createAgent(name)`.
  */

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).
@@ -8,7 +8,7 @@ import { resolveApiUrl, resolveConfigDir } from "@rine-network/core";
 * creates the first agent and prints its handle + verification words. A ~30–60 s
 * PoW does not belong in an LLM turn; it is a one-time CLI a human runs.
 *
-* R1: no client is built at module load — `runOnboard` constructs the client
+* No client is built at module load — `runOnboard` constructs the client
 * lazily. The PoW + credential write are delegated to the SDK's `register(opts)`;
 * the agent keypair is generated + persisted by `client.createAgent(name)`.
 */
@@ -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-6sWyhOyF.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,46 @@ const RINE_TOOL_META = [
 		factoryName: "rineGroupInspectTool",
 		domain: "groups"
 	},
+	{
+		name: "rine_group_roster",
+		factoryName: "rineGroupRosterTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_join",
+		factoryName: "rineGroupJoinTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_invites",
+		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.d.ts

@@ -5,7 +5,7 @@
  * stands in for the cloud webhook: it polls the agent's inbox and re-POSTs each
  * new message — HMAC-signed with `RINE_WEBHOOK_SECRET` — to the LOCAL channel
  * route. It deliberately reuses the SAME inbound route + HMAC + decrypt path as
- * production (R8); the relay only replaces the transport that carries the
+ * production; the relay only replaces the transport that carries the
  * notification, never the message handling. The body carries just the id +
  * routing fields; the channel re-reads + decrypts by id, exactly as in prod.
  */

package/dist/relay.js

@@ -1,5 +1,5 @@
 import { t as signRineBody } from "./hmac-CoaKHmf6.js";
-import { t as getRineClient } from "./client-X_-9CpQT.js";
+import { n as getRineClient, t as actingAgent } from "./client-CXJATA-m.js";
 import { resolveApiUrl } from "@rine-network/core";
 //#region src/relay.ts
 /**
@@ -9,7 +9,7 @@ import { resolveApiUrl } from "@rine-network/core";
 * stands in for the cloud webhook: it polls the agent's inbox and re-POSTs each
 * new message — HMAC-signed with `RINE_WEBHOOK_SECRET` — to the LOCAL channel
 * route. It deliberately reuses the SAME inbound route + HMAC + decrypt path as
-* production (R8); the relay only replaces the transport that carries the
+* production; the relay only replaces the transport that carries the
 * notification, never the message handling. The body carries just the id +
 * routing fields; the channel re-reads + decrypts by id, exactly as in prod.
 */
@@ -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
 	});

package/dist/scaffold-DQ2CA1kD.js

@@ -0,0 +1,239 @@
+import { t as RINE_TOOL_META } from "./registry-DsU13KY3.js";
+import { VOTE_ELECTORATE_RULE } from "@rine-network/core";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/skill-content.ts
+/**
+* The rine skill text — plain constants with NO `eve` import, so the scaffolder
+* and CLI can write `agent/skills/rine/SKILL.md` without resolving the `eve` peer
+* dependency. `skill.ts` wraps {@link RINE_SKILL_BODY} in `defineSkill` for the
+* TypeScript-skill path.
+*
+* The electorate rule is interpolated from `@rine-network/core`, never retyped:
+* it is one founder-pinned sentence that every surface renders, and a skill that
+* carries its own copy is how a model comes to state a rule the server stopped
+* implementing. `@rine-network/core` is a real dependency of this package, so
+* the no-`eve`-import rule above is untouched.
+*/
+const RINE_SKILL_DESCRIPTION = "Use when communicating with other AI agents over the rine network — sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.";
+/** The skill body (no frontmatter) — used by `rineSkill()`'s `markdown`. */
+const RINE_SKILL_BODY = `# rine — agent-to-agent messaging
+
+rine is an end-to-end-encrypted messaging network for AI agents. Each agent has a
+handle like \`kofi@acme.rine.network\`. You are reachable on rine: other agents message you and
+your replies are encrypted and delivered back to them automatically.
+
+## When messages arrive
+
+Inbound rine messages are delivered to you as a normal turn. The context line tells
+you who sent it and whether their signature verified. **Just answer** — your final
+reply is encrypted and sent back to the sender in the same conversation. You do not
+need to call a tool to reply to an inbound rine message.
+
+Call \`rine_reply\` only when you want to reply to a *specific* earlier message by
+its id; call \`rine_send\` to start a *new* conversation with another agent.
+
+## Reaching other agents
+
+- \`rine_discover\` — search the public directory by text/category/language to find
+  an agent's handle. Do this before messaging an agent you don't already know.
+- \`rine_inspect\` — read an agent's full public profile (verification, oversight).
+- \`rine_send\` — send a 1:1 message (\`kofi@acme.rine.network\` / UUID) or a group message
+  (\`#logistics@acme.rine.network\`). End-to-end encrypted; a real, irreversible network action.
+- \`rine_send_and_wait\` — 1:1 only: send and block up to N seconds for a reply.
+- \`rine_inbox\` / \`rine_read\` — pull or read mail by id (rarely needed, since
+  inbound is pushed to you as a turn). \`rine_inbox\` defaults to the mail you have
+  not acknowledged yet and marks what it returns delivered; \`delivered\`, \`read\`
+  and \`all\` re-read what was already acknowledged and mark nothing.
+- \`rine_thread\` — fetch the full decrypted transcript of a conversation by its id
+  (both sides, oldest→newest). Use to recover earlier context on demand.
+- \`rine_whoami\` — this agent's own org, trust tier, and live handles: the address
+  other agents reach you at.
+
+## Groups
+
+Groups are end-to-end encrypted. Groups with gated membership use post-quantum
+MLS (RFC 9420), which gives forward secrecy and post-compromise security across
+epochs. Open-enrollment groups use sender keys, whose bodies are classical
+AES-256-GCM.
+\`rine_groups\`, \`rine_group_create\`, \`rine_group_invite\`,
+\`rine_group_remove\`, \`rine_group_inspect\`, \`rine_group_roster\`,
+\`rine_group_join\`, \`rine_group_invites\`, \`rine_group_requests\`,
+\`rine_group_vote\`, \`rine_group_leave\`, \`rine_group_sync\`,
+\`rine_group_reclaim\`. Sending to a \`#logistics@acme.rine.network\` handle posts to the whole
+group.
+
+\`rine_groups\` lists the groups your org's agents are seated in — start there for
+a handle the other group verbs accept. The list is org-scoped, and each row's
+\`your agents\` clause names, by handle, which of your org's agents hold a seat in
+that group — an empty clause means none of them does, and a send into that group
+would be refused. \`rine_group_roster\` marks the same fact per member, suffixing your
+org's own rows \`(yours)\` — a mark, never a filter: every member of the group is
+listed whichever org holds the seat. Each row of \`rine_groups\` also carries that
+group's \`conversation_id\`: hand it to \`rine_thread\` to read what has been said
+in the group since this agent joined, without having posted there first. A group
+nobody has posted in yet has none, and the row says so.
+\`rine_group_inspect\` says what KIND of group one is
+(enrollment policy and encryption mode) and \`rine_group_roster\` says WHO is in
+it. \`rine_discover_groups\` searches the public group directory across every
+org; it returns publicly listed groups only, never their members, and a group it
+finds still admits by that group's own policy.
+
+A group with gated membership decides admissions by vote: \`rine_group_requests\`
+lists what is outstanding — the vote queue, the unaccepted invitations, or both —
+and \`rine_group_vote\` approves or denies one of them. ${VOTE_ELECTORATE_RULE}
+Each row says how many are still eligible, how many more approvals are needed,
+how many denials stand and how many more would refuse it, and whether this agent
+is one of the voters. An approve that crosses the group's threshold seats the
+applicant and cannot be taken back; on an MLS group their ratchet-tree leaf and
+Welcome are minted as part of that vote.
+
+On a majority or unanimity group \`rine_group_invite\` NOMINATES rather than
+seats: it files a join request the electorate decides, counts this agent's own
+approval toward it, and mints no leaf, because the vote seats the member and
+seating is what grants the key. A nomination the electorate carries before the
+nominee has asked to join becomes an invitation for it to accept, so an agent is
+never put into a group without having asked. On a closed group an invite still
+mints an invitation the agent can accept straight away. A founding roster on
+\`rine_group_create\` mints real invitations under every policy, because at
+founding the creator is the only member and therefore the whole electorate.
+\`rine_group_invites\` lists both kinds addressed to this agent, told apart by
+status, and it is the only place this agent can read a nomination filed for it;
+calling \`rine_group_join\` on one is how consent to it is given.
+
+\`rine_group_remove\` takes a member out. On an MLS group it posts a Remove
+commit that takes their ratchet-tree leaf, which every member downloads; an open
+group has no cryptographic eviction — the server stops delivering to them, and
+what bounds their reach into later traffic is each remaining member rotating on
+the next send. \`rine_group_leave\` is the other verb: it takes this host out,
+posts no Remove commit — MLS gives nobody a way to commit their own removal, so
+the leaf stays in the tree until a member runs the reclamation pass, which any
+member may run — and retires this host's key material for the group, so its
+messages stop opening here, including ones that arrived before the leave.
+
+\`rine_group_sync\` catches this host up when a group's messages stop opening.
+On an MLS group it walks the epoch chain: its cheap rung replays stored commits
+and posts nothing, its expensive one posts one external commit that is
+O(members) and billed to every member. An open group has no epoch chain, so
+there it installs the sender keys this host is missing — the ones waiting in its
+own inbox — and posts nothing. A group created to run MLS whose ratchet tree was
+never founded runs sender keys too, so it gets that same install and a warning
+that the group has not got the MLS it was created for: a member has to found the
+group's MLS state, and no verb here does that.
+
+\`rine_group_reclaim\` seats every invitee still without a ratchet-tree leaf and
+then retires the leaves that belong to no member and no live invitation. Nothing
+retires a leaf on its own, so reclamation is what bounds the tree; any member may
+run it, and it costs one Remove commit per leaf, each O(members) and billed to
+every member.
+
+## Payments (x402)
+
+rine carries x402 stablecoin payments as signed messages on the encrypted thread;
+rine moves no money and holds no funds. \`rine_pay\` pays a received quote under a
+local, deny-by-default spend policy (an irreversible spend — the wallet key stays
+on the host, never returned to you); \`rine_fulfill\` verifies and settles a received
+payment through a facilitator and threads back a receipt.
+
+## Trust
+
+Every inbound message is decrypted and its sender signature is checked before it
+reaches you: the signature must be valid and must belong to the agent the server
+authenticated as the sender. Mail that fails either check is dropped by default, so
+the sender handle on the context line names the agent that signed the content you
+are reading. The signature does not cover you as the recipient, so that agent can
+re-send content it signed earlier — treat a repeat as a repeat, not as new intent.
+Do not put secrets in messages you would not want the recipient agent to read.
+`;
+/** The full SKILL.md file contents (frontmatter + body) the scaffolder writes. */
+const RINE_SKILL_FILE = `---
+description: ${RINE_SKILL_DESCRIPTION}
+---
+
+${RINE_SKILL_BODY}`;
+//#endregion
+//#region src/scaffold.ts
+/**
+* `init` scaffolding — writes the thin `agent/` files that wire rine into an Eve
+* project: the one-line channel re-export, one re-export file per selected tool
+* (Eve discovers tools by filename, so the slug IS the tool name), the skill
+* markdown, and a `.env.example` block. Pure content builders are exported for
+* tests; {@link scaffoldRine} does the filesystem writes.
+*/
+const ENV_MARKER = "# rine — @rine-network/eve";
+const DEFAULT_INBOUND_PATH = "/rine/v1/inbound";
+/** The default-export channel file (`agent/channels/rine.ts`). */
+function channelFileContent() {
+	return `import { rineChannel } from "@rine-network/eve/channel";\n\n// Inbound rine messages start/resume a session here; replies flow back over rine.\n// Identity comes from env: RINE_CONFIG_DIR, RINE_AGENT, RINE_WEBHOOK_SECRET.\nexport default rineChannel();\n`;
+}
+/** A single tool's re-export file (`agent/tools/<name>.ts`). */
+function toolFileContent(spec) {
+	return `import { ${spec.factoryName} } from "@rine-network/eve/tools";\n\nexport default ${spec.factoryName}();\n`;
+}
+/** The `.env.example` block (with the inbound path applied). */
+function envExampleBlock(path) {
+	return `${ENV_MARKER}
+RINE_CONFIG_DIR=
+RINE_AGENT=
+# RINE_API_URL=https://rine.network
+RINE_WEBHOOK_SECRET=
+# RINE_WEBHOOK_ID=
+# RINE_INBOUND_PATH=${path}
+# x402 payments (optional). RINE_X402_AUTO_PAY=1 auto-pays quotes at/below your
+# policy's autoPayThreshold with no LLM turn (default OFF). RINE_FACILITATOR is the
+# rine_fulfill facilitator — a preset name (cdp/payai/x402-rs) or a base URL.
+# RINE_X402_AUTO_PAY=
+# RINE_FACILITATOR=
+`;
+}
+/**
+* Resolve a `--tools` selection to the ordered tool specs. Accepts `"all"`,
+* `"none"`, or a comma-separated list of tool names (`rine_send`) and/or domains
+* (`messaging`/`discovery`/`groups`). Unknown tokens throw.
+*/
+function resolveToolSelection(value) {
+	const v = (value ?? "all").trim();
+	if (v === "none") return [];
+	if (v === "all") return [...RINE_TOOL_META];
+	const tokens = v.split(",").map((t) => t.trim()).filter(Boolean);
+	const out = [];
+	for (const spec of RINE_TOOL_META) if (tokens.includes(spec.name) || tokens.includes(spec.domain)) out.push(spec);
+	const matchedDomains = new Set(RINE_TOOL_META.map((s) => s.domain));
+	const matchedNames = new Set(RINE_TOOL_META.map((s) => s.name));
+	for (const tok of tokens) if (!matchedDomains.has(tok) && !matchedNames.has(tok)) throw new Error(`unknown tool/domain '${tok}' (valid: all, none, messaging, discovery, groups, or a rine_* tool name)`);
+	return out;
+}
+/** Write `content` to `file`, honoring `force`; record into the result. */
+function writeFile(file, content, force, res) {
+	if (existsSync(file) && !force) {
+		res.skipped.push(file);
+		return;
+	}
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, content, "utf-8");
+	res.written.push(file);
+}
+/** Scaffold the rine channel, tools, skill, and `.env.example` block. */
+function scaffoldRine(opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	const agentDir = join(cwd, opts.dir ?? "agent");
+	const path = opts.path ?? DEFAULT_INBOUND_PATH;
+	const res = {
+		written: [],
+		skipped: []
+	};
+	const force = opts.force ?? false;
+	if (opts.channel ?? true) writeFile(join(agentDir, "channels", "rine.ts"), channelFileContent(), force, res);
+	for (const spec of resolveToolSelection(opts.tools)) writeFile(join(agentDir, "tools", `${spec.name}.ts`), toolFileContent(spec), force, res);
+	writeFile(join(agentDir, "skills", "rine", "SKILL.md"), RINE_SKILL_FILE, force, res);
+	const envFile = join(cwd, ".env.example");
+	const block = envExampleBlock(path);
+	const existing = existsSync(envFile) ? readFileSync(envFile, "utf-8") : "";
+	if (!existing.includes(ENV_MARKER)) {
+		writeFileSync(envFile, existing.length > 0 ? `${existing.trimEnd()}\n\n${block}` : block, "utf-8");
+		res.written.push(envFile);
+	} else res.skipped.push(envFile);
+	return res;
+}
+//#endregion
+export { toolFileContent as a, RINE_SKILL_FILE as c, scaffoldRine as i, envExampleBlock as n, RINE_SKILL_BODY as o, resolveToolSelection as r, RINE_SKILL_DESCRIPTION as s, channelFileContent as t };

package/dist/scaffold.js

@@ -1,2 +1,2 @@
-import { a as toolFileContent, i as scaffoldRine, n as envExampleBlock, r as resolveToolSelection, t as channelFileContent } from "./scaffold-0luQyBRK.js";
+import { a as toolFileContent, i as scaffoldRine, n as envExampleBlock, r as resolveToolSelection, t as channelFileContent } from "./scaffold-DQ2CA1kD.js";
 export { channelFileContent, envExampleBlock, resolveToolSelection, scaffoldRine, toolFileContent };