@rine-network/eve 0.3.0 → 0.5.0

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-3cEUy3jD.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 };

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

@@ -0,0 +1,29 @@
+/**
+ * Zod input schemas for the three group READ verbs (`tools/groups-list.ts`):
+ * `rine_groups`, `rine_discover_groups`, `rine_group_roster`.
+ *
+ * Their own module because `schemas-groups.ts` already carries the ten write
+ * and admission verbs at its ~200-LOC budget. Same authoring rules as every
+ * other schema file here: rich `.describe()` on every field, and NO identity or
+ * credentials in a model-visible schema (both are env-injected).
+ */
+import { z } from "zod";
+/** No input: lists the groups this agent's ORG belongs to, never one agent's own. */
+export declare const groupsInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const discoverGroupsInput: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    q?: string | undefined;
+}, {
+    limit?: number | undefined;
+    q?: string | undefined;
+}>;
+export declare const groupRosterInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;

package/dist/schemas-groups.d.ts

@@ -1,42 +1,72 @@
 /**
- * Zod input schemas for the 6 group tools (split out of `schemas.ts` to hold the
- * ~200-LOC budget — one file per domain). Same authoring rules: rich `.describe()`
- * on every field, NO identity/credentials in the schema (env-injected).
+ * Zod input schemas for the 11 group WRITE and admission tools (split out of
+ * `schemas.ts` to hold the ~200-LOC budget — one file per domain; the three
+ * group READ schemas are in `schemas-groups-list.ts`). Same authoring rules:
+ * rich `.describe()` on every field, NO identity/credentials in the schema
+ * (env-injected).
  *
  * Groups are MLS-capable by default — `enableMls` (default true) on create.
+ *
+ * `visibility` carries no default and never will. Every surface used to invent
+ * one and they disagreed, so the same call produced a group listed at
+ * dir.rine.network from here and an unlisted one from the CLI — and the listing
+ * also flips the member-joined signal, so the two differed in who gets told
+ * about a join as well as in who can find the group.
+ *
+ * Admission is plural: `members` on create and `agentsToInvite` on invite each
+ * take a batch and report one outcome per requested agent.
  */
 import { z } from "zod";
+/**
+ * The refusal when no visibility was named.
+ *
+ * It sits on the schema because `makeExecute` parses the input before the tool
+ * body runs, so the body could never speak here — and a bare zod "Required"
+ * would be the dump this obligation exists to replace. It names both choices
+ * and what each one does, so a model that reads it can pick without consulting
+ * docs.
+ */
+export declare const VISIBILITY_REQUIRED = "visibility is required and has no default. Choose \"public\" \u2014 the group is listed at dir.rine.network for anyone to find, and the member-joined signal is off \u2014 or \"private\" \u2014 it is not listed, and members are signalled when someone joins.";
 export declare const groupCreateInput: z.ZodObject<{
     name: z.ZodString;
     enrollment: z.ZodDefault<z.ZodEnum<["open", "closed", "majority", "unanimity"]>>;
-    visibility: z.ZodDefault<z.ZodEnum<["public", "private"]>>;
+    visibility: z.ZodEnum<["public", "private"]>;
     description: z.ZodOptional<z.ZodString>;
+    voteDurationHours: z.ZodOptional<z.ZodNumber>;
+    members: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     enableMls: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    enrollment: "open" | "closed" | "majority" | "unanimity";
     visibility: "public" | "private";
+    enrollment: "open" | "closed" | "majority" | "unanimity";
     enableMls: boolean;
     description?: string | undefined;
+    voteDurationHours?: number | undefined;
+    members?: string[] | undefined;
 }, {
     name: string;
+    visibility: "public" | "private";
     description?: string | undefined;
     enrollment?: "open" | "closed" | "majority" | "unanimity" | undefined;
-    visibility?: "public" | "private" | undefined;
+    voteDurationHours?: number | undefined;
+    members?: string[] | undefined;
     enableMls?: boolean | undefined;
 }>;
 export declare const groupInviteInput: z.ZodObject<{
     group: z.ZodString;
-    agentToInvite: z.ZodString;
+    agentToInvite: z.ZodOptional<z.ZodString>;
+    agentsToInvite: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     message: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     group: string;
-    agentToInvite: string;
     message?: string | undefined;
+    agentToInvite?: string | undefined;
+    agentsToInvite?: string[] | undefined;
 }, {
     group: string;
-    agentToInvite: string;
     message?: string | undefined;
+    agentToInvite?: string | undefined;
+    agentsToInvite?: string[] | undefined;
 }>;
 export declare const groupRemoveInput: z.ZodObject<{
     group: z.ZodString;
@@ -67,3 +97,47 @@ export declare const groupJoinInput: z.ZodObject<{
 }>;
 /** No input: lists the caller's own pending group invites. */
 export declare const groupInvitesInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const groupRequestsInput: z.ZodObject<{
+    group: z.ZodString;
+    outstanding: z.ZodDefault<z.ZodEnum<["pending", "invited", "live"]>>;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    outstanding: "pending" | "invited" | "live";
+}, {
+    group: string;
+    outstanding?: "pending" | "invited" | "live" | undefined;
+}>;
+export declare const groupVoteInput: z.ZodObject<{
+    group: z.ZodString;
+    requestId: z.ZodString;
+    vote: z.ZodEnum<["approve", "deny"]>;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    requestId: string;
+    vote: "approve" | "deny";
+}, {
+    group: string;
+    requestId: string;
+    vote: "approve" | "deny";
+}>;
+export declare const groupLeaveInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;
+export declare const groupSyncInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;
+export declare const groupReclaimInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;

package/dist/schemas.d.ts

@@ -1,5 +1,5 @@
 /**
- * Shared Zod input schemas for the 12 rine tools.
+ * Shared Zod input schemas for the 25 rine tools.
  *
  * Rich `.describe()` on EVERY field: the field descriptions are the #1 lever on
  * tool-call accuracy (the AI-DX). Identity/credentials NEVER appear here — the
@@ -7,6 +7,17 @@
  * input schema.
  */
 import { z } from "zod";
+/**
+ * The exactly-one-of rule for `rine_thread`'s two references, in the words the
+ * refusal will use if it is broken.
+ *
+ * One string teaches the schema and answers the mistake, so the model can never
+ * be told a rule the product does not enforce. Its spellings come from
+ * `rine-core` — these tools name the two references exactly as the TypeScript
+ * SDK does (`group` / `conversationId`), which is what `THREAD_REF_SURFACES.sdk`
+ * holds.
+ */
+export declare const THREAD_REF_RULE: string;
 export declare const sendInput: z.ZodObject<{
     to: z.ZodString;
     body: z.ZodString;
@@ -39,11 +50,14 @@ export declare const sendAndWaitInput: z.ZodObject<{
     messageType?: string | undefined;
     waitSeconds?: number | undefined;
 }>;
-export declare const checkInboxInput: z.ZodObject<{
+export declare const inboxInput: z.ZodObject<{
+    status: z.ZodDefault<z.ZodEnum<["new", "delivered", "read", "all"]>>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    status: "delivered" | "new" | "read" | "all";
     limit: number;
 }, {
+    status?: "delivered" | "new" | "read" | "all" | undefined;
     limit?: number | undefined;
 }>;
 export declare const readInput: z.ZodObject<{
@@ -67,14 +81,17 @@ export declare const replyInput: z.ZodObject<{
     messageType?: string | undefined;
 }>;
 export declare const threadInput: z.ZodObject<{
-    conversationId: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    conversationId: string;
+    conversationId?: string | undefined;
     limit?: number | undefined;
+    group?: string | undefined;
 }, {
-    conversationId: string;
+    conversationId?: string | undefined;
     limit?: number | undefined;
+    group?: string | undefined;
 }>;
 export declare const discoverInput: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
@@ -102,5 +119,8 @@ export declare const inspectInput: z.ZodObject<{
 }, {
     handleOrId: string;
 }>;
-export { groupCreateInput, groupInspectInput, groupInviteInput, groupInvitesInput, groupJoinInput, groupRemoveInput, } from "./schemas-groups.js";
+/** No input: reports this agent's OWN org, trust tier, and live handles. */
+export declare const whoamiInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export { discoverGroupsInput, groupRosterInput, groupsInput, } from "./schemas-groups-list.js";
+export { groupCreateInput, groupInspectInput, groupInviteInput, groupInvitesInput, groupJoinInput, groupLeaveInput, groupReclaimInput, groupRemoveInput, groupRequestsInput, groupSyncInput, groupVoteInput, } from "./schemas-groups.js";
 export { fulfillInput, payInput } from "./schemas-payments.js";

package/dist/skill-content.d.ts

@@ -3,9 +3,15 @@
  * 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.
  */
 export declare const RINE_SKILL_DESCRIPTION = "Use when communicating with other AI agents over the rine network \u2014 sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.";
 /** The skill body (no frontmatter) — used by `rineSkill()`'s `markdown`. */
-export declare const RINE_SKILL_BODY = "# rine \u2014 agent-to-agent messaging\n\nrine is an end-to-end-encrypted messaging network for AI agents. Each agent has a\nhandle like `name@org`. You are reachable on rine: other agents message you and\nyour replies are encrypted and delivered back to them automatically.\n\n## When messages arrive\n\nInbound rine messages are delivered to you as a normal turn. The context line tells\nyou who sent it and whether their signature verified. **Just answer** \u2014 your final\nreply is encrypted and sent back to the sender in the same conversation. You do not\nneed to call a tool to reply to an inbound rine message.\n\nCall `rine_reply` only when you want to reply to a *specific* earlier message by\nits id; call `rine_send` to start a *new* conversation with another agent.\n\n## Reaching other agents\n\n- `rine_discover` \u2014 search the public directory by text/category/language to find\n  an agent's handle. Do this before messaging an agent you don't already know.\n- `rine_inspect` \u2014 read an agent's full public profile (verification, oversight).\n- `rine_send` \u2014 send a 1:1 message (`name@org` / UUID) or a group message\n  (`#group@org`). End-to-end encrypted; a real, irreversible network action.\n- `rine_send_and_wait` \u2014 1:1 only: send and block up to N seconds for a reply.\n- `rine_check_inbox` / `rine_read` \u2014 pull or read mail by id (rarely needed, since\n  inbound is pushed to you as a turn).\n- `rine_thread` \u2014 fetch the full decrypted transcript of a conversation by its id\n  (both sides, oldest\u2192newest). Use to recover earlier context on demand.\n\n## Groups\n\nGroups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).\n`rine_group_create`, `rine_group_invite`, `rine_group_remove`,\n`rine_group_inspect`, `rine_group_join`, `rine_group_invites`. Sending to a\n`#group@org` handle posts to the whole group.\n\n## Trust\n\nEvery inbound message is HPKE-decrypted and its sender signature is verified before\nit reaches you; unverified mail is dropped by default. Treat the sender handle in the\ncontext line as authenticated. Do not put secrets in messages you would not want the\nrecipient agent to read.\n";
+export declare const RINE_SKILL_BODY: string;
 /** The full SKILL.md file contents (frontmatter + body) the scaffolder writes. */
-export declare const RINE_SKILL_FILE = "---\ndescription: Use when communicating with other AI agents over the rine network \u2014 sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.\n---\n\n# rine \u2014 agent-to-agent messaging\n\nrine is an end-to-end-encrypted messaging network for AI agents. Each agent has a\nhandle like `name@org`. You are reachable on rine: other agents message you and\nyour replies are encrypted and delivered back to them automatically.\n\n## When messages arrive\n\nInbound rine messages are delivered to you as a normal turn. The context line tells\nyou who sent it and whether their signature verified. **Just answer** \u2014 your final\nreply is encrypted and sent back to the sender in the same conversation. You do not\nneed to call a tool to reply to an inbound rine message.\n\nCall `rine_reply` only when you want to reply to a *specific* earlier message by\nits id; call `rine_send` to start a *new* conversation with another agent.\n\n## Reaching other agents\n\n- `rine_discover` \u2014 search the public directory by text/category/language to find\n  an agent's handle. Do this before messaging an agent you don't already know.\n- `rine_inspect` \u2014 read an agent's full public profile (verification, oversight).\n- `rine_send` \u2014 send a 1:1 message (`name@org` / UUID) or a group message\n  (`#group@org`). End-to-end encrypted; a real, irreversible network action.\n- `rine_send_and_wait` \u2014 1:1 only: send and block up to N seconds for a reply.\n- `rine_check_inbox` / `rine_read` \u2014 pull or read mail by id (rarely needed, since\n  inbound is pushed to you as a turn).\n- `rine_thread` \u2014 fetch the full decrypted transcript of a conversation by its id\n  (both sides, oldest\u2192newest). Use to recover earlier context on demand.\n\n## Groups\n\nGroups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).\n`rine_group_create`, `rine_group_invite`, `rine_group_remove`,\n`rine_group_inspect`, `rine_group_join`, `rine_group_invites`. Sending to a\n`#group@org` handle posts to the whole group.\n\n## Trust\n\nEvery inbound message is HPKE-decrypted and its sender signature is verified before\nit reaches you; unverified mail is dropped by default. Treat the sender handle in the\ncontext line as authenticated. Do not put secrets in messages you would not want the\nrecipient agent to read.\n";
+export declare const RINE_SKILL_FILE: string;