@oneie/sdk 0.9.0 → 0.10.0

package/dist/receivers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receivers.d.ts","sourceRoot":"","sources":["../src/receivers.ts"],"names":[],"mappings":"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"}

package/dist/receivers.js

@@ -0,0 +1,626 @@
+import { z } from "zod";
+import { AgentActionResponseSchema, AgentStatusResponseSchema, CapabilityItemSchema, PayResponseSchema, RegisterResponseSchema, StatsSchema, } from "./schemas.js";
+/**
+ * Declare a receiver contract. Identity at runtime — its only job is to pin the
+ * `Req`/`Res` generics so the catalog infers payload + outcome types.
+ */
+export function receiver(r) {
+    return r;
+}
+const ok = z.object({ ok: z.boolean() });
+/**
+ * The receiver catalog — one source of truth for capability. Object-literal keys
+ * are always literal, so `keyof typeof RECEIVERS` yields the declared receiver
+ * names and `ask<R>` infers payload + outcome by inference (no codegen).
+ *
+ * Populated incrementally: C2 = spine + 21 `world:*` + `grant-capability`;
+ * C4 = remaining families with metadata; C5 = the `meta:` family.
+ */
+export const RECEIVERS = {
+    // ── Spine (non-world) — contracts only this cycle; route-wiring lands in C4 ──
+    "auth:agent": receiver({
+        receiver: "auth:agent",
+        summary: "Become an actor — mint a uid, wallet, and scoped API key",
+        request: z.object({ name: z.string().optional(), uid: z.string().optional(), kind: z.string().optional() }),
+        response: z.object({
+            uid: z.string(), name: z.string(), kind: z.string(),
+            wallet: z.string().nullable(), apiKey: z.string(), keyId: z.string(), returning: z.boolean(),
+        }),
+        effect: "ask",
+        reversible: false,
+        idempotent: true,
+    }),
+    "agents:sync": receiver({
+        receiver: "agents:sync",
+        summary: "Declare capability — sync agent definitions, skills, and memberships",
+        // Accepts a single markdown body or a structured multi-agent world payload.
+        request: z.union([
+            z.object({ markdown: z.string() }),
+            z.object({
+                agents: z.array(z.object({ name: z.string().optional(), content: z.string() })),
+                world: z.string().optional(),
+                description: z.unknown().optional(),
+            }),
+        ]),
+        response: z.object({
+            ok: z.boolean(), agent: z.string().optional(), uid: z.string().optional(),
+            wallet: z.string().nullable().optional(), suiObjectId: z.string().nullable().optional(),
+            skills: z.array(z.string()).optional(), world: z.string().optional(),
+        }).passthrough(),
+        effect: "ask",
+    }),
+    // ── world:* — workspace / actor / thing / key / path / learning mutations ──
+    "world:create-workspace": receiver({
+        receiver: "world:create-workspace",
+        summary: "Create a workspace; optionally provision a full billing-aware client (parent + credits + brand + starter agents) in one atomic call",
+        request: z.object({
+            name: z.string(),
+            slug: z.string(),
+            ownerEmail: z.string().email().optional(),
+            // Extended atomic client provision (optional — omit for a bare workspace).
+            parent: z.string().optional(),
+            plan: z.enum(["free", "pro", "studio", "agency", "enterprise"]).optional(),
+            credit: z.number().int().nonnegative().optional(),
+            markup: z.number().int().min(0).max(100).optional(),
+            cap: z.number().int().nonnegative().nullable().optional(),
+            brand: z.boolean().optional(),
+            agents: z.array(z.string()).optional(),
+        }),
+        response: z.object({ wsid: z.string(), slug: z.string() }),
+        effect: "ask", auth: "manage_workspace", reversible: false,
+        examples: [
+            { name: "Acme", slug: "acme", ownerEmail: "owner@acme.com" },
+            { name: "Acme", slug: "acme", parent: "donal", plan: "studio", credit: 50000, markup: 20, cap: 50000, brand: true, agents: ["sales", "support"] },
+        ],
+    }),
+    "world:invite-client": receiver({
+        receiver: "world:invite-client",
+        summary: "Agency mints a scoped invite; on accept the invitee owns a new workspace parented under the agency",
+        request: z.object({
+            slug: z.string(),
+            name: z.string().optional(),
+            email: z.string().email().optional(),
+            plan: z.enum(["free", "pro", "studio", "agency", "enterprise"]).optional(),
+            credits: z.number().int().nonnegative().optional(),
+            markup: z.number().int().min(0).max(100).optional(),
+            cap: z.number().int().nonnegative().nullable().optional(),
+            brand: z.boolean().optional(),
+            agents: z.array(z.string()).optional(),
+        }),
+        response: z.object({ token: z.string(), id: z.string(), child: z.string(), expiresAt: z.number() }),
+        effect: "ask", auth: "manage_clients", reversible: false,
+        examples: [{ slug: "beta", email: "owner@beta.com", plan: "studio", credits: 50000, markup: 20 }],
+    }),
+    "world:accept-client-invite": receiver({
+        receiver: "world:accept-client-invite",
+        summary: "Redeem a client invite — creates the workspace owned by the invitee (single-use, replay-protected)",
+        request: z.object({ token: z.string(), email: z.string().email().optional(), name: z.string().optional() }),
+        response: z.object({ wsid: z.string(), slug: z.string(), owner: z.string(), parent: z.string() }),
+        effect: "ask", reversible: false, idempotent: false,
+    }),
+    "world:invite-member": receiver({
+        receiver: "world:invite-member",
+        summary: "Invite a human member to a workspace",
+        request: z.object({ workspace: z.string(), email: z.string().email(), role: z.string().optional() }),
+        response: z.object({ ok: z.boolean(), uid: z.string() }),
+        effect: "ask", auth: "manage_members",
+    }),
+    "world:remove-member": receiver({
+        receiver: "world:remove-member",
+        summary: "Remove a member from a workspace",
+        request: z.object({ workspace: z.string(), aid: z.string() }),
+        response: ok, effect: "ask", auth: "manage_members", reversible: false,
+    }),
+    "world:suspend-workspace": receiver({
+        receiver: "world:suspend-workspace",
+        summary: "Suspend a workspace",
+        request: z.object({ workspace: z.string() }),
+        response: ok, effect: "ask", auth: "manage_workspace",
+    }),
+    "world:create-group": receiver({
+        receiver: "world:create-group",
+        summary: "Create a group in the caller's workspace",
+        request: z.object({ name: z.string(), type: z.string(), tags: z.array(z.string()).optional() }),
+        response: z.object({ gid: z.string() }), effect: "ask", auth: "manage_groups",
+    }),
+    "world:update-group": receiver({
+        receiver: "world:update-group",
+        summary: "Update a group's name, tags, or meta",
+        request: z.object({ gid: z.string(), name: z.string().optional(), tags: z.array(z.string()).optional(), meta: z.unknown().optional() }),
+        response: ok, effect: "ask", auth: "manage_groups",
+    }),
+    "world:remove-group": receiver({
+        receiver: "world:remove-group",
+        summary: "Delete a group",
+        request: z.object({ gid: z.string() }), response: ok, effect: "ask", auth: "manage_groups", reversible: false,
+    }),
+    "world:create-actor": receiver({
+        receiver: "world:create-actor",
+        summary: "Create an actor (agent or human) in the world",
+        request: z.object({
+            name: z.string(), type: z.string(), group: z.string().optional(),
+            tags: z.array(z.string()).optional(), model: z.string().optional(), prompt: z.string().optional(),
+        }),
+        response: z.object({ aid: z.string() }), effect: "ask", auth: "manage_actors",
+        examples: [{ name: "scout", type: "agent" }],
+    }),
+    "world:update-actor": receiver({
+        receiver: "world:update-actor",
+        summary: "Update an actor's name, tags, prompt, or model",
+        request: z.object({ aid: z.string(), name: z.string().optional(), tags: z.array(z.string()).optional(), prompt: z.string().optional(), model: z.string().optional() }),
+        response: ok, effect: "ask", auth: "manage_actors",
+    }),
+    "world:remove-actor": receiver({
+        receiver: "world:remove-actor",
+        summary: "Delete an actor",
+        request: z.object({ aid: z.string() }), response: ok, effect: "ask", auth: "manage_actors", reversible: false,
+    }),
+    "world:create-key": receiver({
+        receiver: "world:create-key",
+        summary: "Mint a scoped API key for an actor",
+        request: z.object({ actor: z.string(), scope: z.string().optional(), label: z.string().optional() }),
+        response: z.object({ key: z.string(), keyId: z.string() }), effect: "ask", auth: "manage_keys",
+        reversible: false,
+    }),
+    "world:revoke-key": receiver({
+        receiver: "world:revoke-key",
+        summary: "Revoke an API key",
+        request: z.object({ keyId: z.string() }), response: ok, effect: "ask", auth: "manage_keys", reversible: false,
+    }),
+    "world:create-thing": receiver({
+        receiver: "world:create-thing",
+        summary: "Create a thing (skill, token, product) in the world",
+        request: z.object({ name: z.string(), type: z.string(), group: z.string().optional(), tags: z.array(z.string()).optional(), price: z.number().optional() }),
+        response: z.object({ tid: z.string() }), effect: "ask", auth: "manage_things",
+    }),
+    "world:update-thing": receiver({
+        receiver: "world:update-thing",
+        summary: "Update a thing's name, tags, price, or meta",
+        request: z.object({ tid: z.string(), name: z.string().optional(), tags: z.array(z.string()).optional(), price: z.number().optional(), meta: z.unknown().optional() }),
+        response: ok, effect: "ask", auth: "manage_things",
+    }),
+    "world:remove-thing": receiver({
+        receiver: "world:remove-thing",
+        summary: "Delete a thing",
+        request: z.object({ tid: z.string() }), response: ok, effect: "ask", auth: "manage_things", reversible: false,
+    }),
+    "world:freeze-path": receiver({
+        receiver: "world:freeze-path",
+        summary: "Freeze a path so decay cannot weaken it",
+        request: z.object({ edge: z.string() }), response: ok, effect: "ask", auth: "manage_paths",
+    }),
+    "world:unfreeze-path": receiver({
+        receiver: "world:unfreeze-path",
+        summary: "Unfreeze a path",
+        request: z.object({ edge: z.string() }), response: ok, effect: "ask", auth: "manage_paths",
+    }),
+    "world:remove-path": receiver({
+        receiver: "world:remove-path",
+        summary: "Delete a path",
+        request: z.object({ edge: z.string() }), response: ok, effect: "ask", auth: "manage_paths", reversible: false,
+    }),
+    "world:create-hypothesis": receiver({
+        receiver: "world:create-hypothesis",
+        summary: "Record a hypothesis for later verification",
+        request: z.object({ claim: z.string(), tags: z.array(z.string()).optional(), confidence: z.number().optional() }),
+        response: z.object({ hid: z.string() }), effect: "ask", auth: "manage_learning",
+    }),
+    "world:promote-hypothesis": receiver({
+        receiver: "world:promote-hypothesis",
+        summary: "Promote a hypothesis to confirmed",
+        request: z.object({ hid: z.string() }), response: ok, effect: "ask", auth: "manage_learning",
+    }),
+    "world:reject-hypothesis": receiver({
+        receiver: "world:reject-hypothesis",
+        summary: "Reject a hypothesis with a reason",
+        request: z.object({ hid: z.string(), reason: z.string().optional() }), response: ok, effect: "ask", auth: "manage_learning",
+    }),
+    // ── grant-capability — capability grant (intercepted in signal/[receiver].ts) ──
+    "grant-capability": receiver({
+        receiver: "grant-capability",
+        summary: "Issue a scoped, time-boxed capability grant to a principal",
+        request: z.object({
+            grantee: z.string().min(1),
+            actions: z.array(z.string()).min(1),
+            scope: z.string().min(1),
+            valid_from: z.number(),
+            valid_to: z.number(),
+        }).refine((g) => g.valid_to > g.valid_from, { message: "valid_to must be after valid_from", path: ["valid_to"] }),
+        response: z.object({ outcome: z.literal("granted"), id: z.string(), grantee: z.string(), scope: z.string() }),
+        effect: "ask", auth: "mint_capability", reversible: false,
+    }),
+    // ════════════════════════════════════════════════════════════════════════
+    // C4 — remaining families (sequenced by recipe: identity → groups → BUILD
+    // → TRADE → TRANSACT → reads). Request schemas mirror the exact client.ts
+    // call sites so a wrong payload is a compile error (the C3 mechanism).
+    // ════════════════════════════════════════════════════════════════════════
+    // ── identity ──
+    "identity:address": receiver({
+        receiver: "identity:address",
+        summary: "Resolve an actor's wallet address",
+        request: z.object({ uid: z.string() }),
+        response: z.object({ uid: z.string(), address: z.string() }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    // ── auth (human session) ──
+    "auth:sign-in": receiver({
+        receiver: "auth:sign-in",
+        summary: "Sign in a human with email + password",
+        request: z.object({ email: z.string(), password: z.string() }),
+        response: z.object({ sessionId: z.string(), userId: z.string() }),
+        effect: "ask", reversible: false,
+    }),
+    "auth:sign-out": receiver({
+        receiver: "auth:sign-out",
+        summary: "End the current session",
+        request: z.object({}),
+        response: ok,
+        effect: "signal", idempotent: true,
+    }),
+    // ── board ──
+    "board:join": receiver({
+        receiver: "board:join",
+        summary: "Join the public board as an actor",
+        request: z.object({ uid: z.string(), group: z.string().optional() }),
+        response: z.object({ ok: z.boolean(), uid: z.string(), group: z.string(), role: z.string() }),
+        effect: "ask", idempotent: true,
+    }),
+    // ── agency (oo operator surface) ──
+    "agency:push:complete": receiver({
+        receiver: "agency:push:complete",
+        summary: "An agency finished pushing agents/skills — logs the sync event",
+        request: z.object({ agents: z.number().int().nonnegative(), skills: z.number().int().nonnegative() }),
+        response: ok,
+        effect: "signal", idempotent: true,
+    }),
+    "agency:friction": receiver({
+        receiver: "agency:friction",
+        summary: "A /do cycle stalled in an agency repo — surfaces the friction back to ONE",
+        request: z.object({ agency: z.string(), cycle: z.string().nullable(), wave: z.string().nullable(), reason: z.string() }),
+        response: ok,
+        effect: "signal",
+    }),
+    // ── groups ──
+    "groups:join": receiver({
+        receiver: "groups:join",
+        summary: "Join a group",
+        request: z.object({ gid: z.string() }),
+        response: z.object({ ok: z.boolean(), gid: z.string(), role: z.string() }),
+        effect: "signal", idempotent: true,
+    }),
+    "groups:leave": receiver({
+        receiver: "groups:leave",
+        summary: "Leave a group",
+        request: z.object({ gid: z.string() }),
+        response: ok,
+        effect: "signal", idempotent: true,
+    }),
+    "groups:invite": receiver({
+        receiver: "groups:invite",
+        summary: "Invite an actor to a group",
+        request: z.object({ gid: z.string(), uid: z.string(), role: z.string().optional() }),
+        response: ok,
+        effect: "signal", auth: "manage_members",
+    }),
+    "groups:members": receiver({
+        receiver: "groups:members",
+        summary: "List a group's members",
+        request: z.object({ gid: z.string() }),
+        response: z.object({
+            gid: z.string(),
+            members: z.array(z.object({ uid: z.string(), name: z.string().optional(), role: z.string() })),
+        }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "billing:clients": receiver({
+        receiver: "billing:clients",
+        summary: "Agency P&L — per-client funded · burned · margin · balance · cap (margin from the ledger)",
+        request: z.object({}).optional(),
+        response: z.object({
+            agency: z.object({ slug: z.string(), name: z.string().nullable(), markup_pct: z.number(), pool: z.number() }).nullable(),
+            clients: z.array(z.object({
+                slug: z.string(), name: z.string().nullable(), plan: z.string(),
+                funded: z.number(), burned: z.number(), margin: z.number(), balance: z.number(), cap: z.number().nullable(),
+            })),
+        }),
+        effect: "ask", auth: "manage_clients", cost: "free", idempotent: true,
+    }),
+    // ── paths ──
+    "paths:bridge": receiver({
+        receiver: "paths:bridge",
+        summary: "Bridge two actors or groups with a path",
+        request: z.object({ from: z.string(), to: z.string() }),
+        response: z.object({
+            ok: z.boolean().optional(),
+            status: z.enum(["pending", "bridged"]).optional(),
+            key: z.string().optional(), gid: z.string().optional(), awaiting: z.string().optional(),
+        }),
+        effect: "ask",
+    }),
+    // ── subscriptions ──
+    "subscriptions:register": receiver({
+        receiver: "subscriptions:register",
+        summary: "Subscribe to a receiver's events by tag",
+        request: z.object({
+            receiver: z.string(),
+            tags: z.array(z.string()),
+            scope: z.enum(["private", "public"]).optional(),
+        }),
+        response: ok,
+        effect: "signal", idempotent: true,
+    }),
+    // ── agents (TRADE / lifecycle) ──
+    "agents:register": receiver({
+        receiver: "agents:register",
+        summary: "Register an agent as a sellable actor with capabilities",
+        request: z.object({
+            uid: z.string(),
+            kind: z.string().optional(),
+            capabilities: z.array(z.object({ skill: z.string(), price: z.number().optional() })).optional(),
+            wallet: z.string().optional(),
+            chain: z.string().optional(),
+        }),
+        response: RegisterResponseSchema,
+        effect: "ask", idempotent: true,
+    }),
+    "agents:commend": receiver({
+        receiver: "agents:commend",
+        summary: "Commend an agent — strengthen its reputation path",
+        request: z.object({ uid: z.string() }),
+        response: AgentActionResponseSchema,
+        effect: "signal",
+    }),
+    "agents:flag": receiver({
+        receiver: "agents:flag",
+        summary: "Flag an agent — add resistance to its reputation path",
+        request: z.object({ uid: z.string() }),
+        response: AgentActionResponseSchema,
+        effect: "signal",
+    }),
+    "agents:status": receiver({
+        receiver: "agents:status",
+        summary: "Set an agent active or inactive",
+        request: z.object({ uid: z.string(), status: z.string() }),
+        response: AgentStatusResponseSchema,
+        effect: "signal", idempotent: true,
+    }),
+    "agents:capabilities": receiver({
+        receiver: "agents:capabilities",
+        summary: "List an agent's published capabilities",
+        request: z.object({ uid: z.string() }),
+        response: z.array(CapabilityItemSchema),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "agents:deploy-on-behalf": receiver({
+        receiver: "agents:deploy-on-behalf",
+        summary: "Deploy an agent on behalf of an owner, inheriting their paths",
+        request: z.object({ owner: z.string(), spec: z.record(z.string(), z.unknown()) }),
+        response: z.object({
+            ok: z.boolean(), uid: z.string(), owner: z.string(),
+            inheritedPaths: z.array(z.object({ from: z.string(), to: z.string(), strength: z.number() })),
+        }),
+        effect: "ask", reversible: false, simulatable: true,
+    }),
+    // ── pay (TRANSACT — onchain settlement) ──
+    "pay:weight": receiver({
+        receiver: "pay:weight",
+        summary: "Pay for a task by weighting the path between two actors",
+        request: z.object({ from: z.string(), to: z.string(), task: z.string(), amount: z.number() }),
+        response: PayResponseSchema,
+        effect: "ask", cost: "variable", settles: "onchain", reversible: false, simulatable: true,
+    }),
+    // ── market (TRADE) ──
+    "market:hire": receiver({
+        receiver: "market:hire",
+        summary: "Hire an agent for a skill — opens a chat or returns an escrow template",
+        request: z.object({ providerUid: z.string(), skillId: z.string(), initialMessage: z.string().optional() }),
+        response: z.union([
+            z.object({ ok: z.literal(true), groupId: z.string(), chatUrl: z.string() }),
+            z.object({
+                status: z.literal(402), code: z.string(),
+                escrow_template: z.record(z.string(), z.unknown()), expires_at: z.string(),
+            }),
+        ]),
+        effect: "ask", cost: "variable", settles: "onchain", reversible: false, simulatable: true,
+    }),
+    "market:bounty": receiver({
+        receiver: "market:bounty",
+        summary: "Post a bounty for a skill, backed by an escrow",
+        request: z.object({
+            skillId: z.string(), sellerUid: z.string(), posterUid: z.string(), price: z.number(),
+            tags: z.array(z.string()).optional(),
+            content: z.record(z.string(), z.unknown()).optional(),
+            rubric: z.object({
+                fit: z.number().optional(), form: z.number().optional(),
+                truth: z.number().optional(), taste: z.number().optional(),
+            }).optional(),
+            deadline: z.string().optional(),
+            posterUnitObjectId: z.string().optional(),
+            workerUnitObjectId: z.string().optional(),
+            pathObjectId: z.string().optional(),
+        }),
+        response: z.object({ id: z.string(), escrowId: z.string().optional(), data: z.record(z.string(), z.unknown()) }),
+        effect: "ask", cost: "variable", settles: "onchain", reversible: false, simulatable: true,
+    }),
+    "market:bounties": receiver({
+        receiver: "market:bounties",
+        summary: "List bounties, optionally filtered by seller or poster",
+        request: z.object({ seller: z.string().optional(), poster: z.string().optional() }),
+        response: z.array(z.object({
+            id: z.string(), skillId: z.string(), sellerUid: z.string(), posterUid: z.string(), price: z.number(),
+            tags: z.array(z.string()).optional(), deadline: z.string().optional(), status: z.string(),
+        })),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "market:list": receiver({
+        receiver: "market:list",
+        summary: "List the capability market",
+        request: z.object({ tag: z.string().optional(), maxPrice: z.number().optional() }),
+        response: z.object({ capabilities: z.array(z.unknown()) }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    // ── capabilities ──
+    "capabilities:publish": receiver({
+        receiver: "capabilities:publish",
+        summary: "Publish a capability (skill listing) to the market",
+        request: z.object({
+            skillId: z.string(), name: z.string(), price: z.number(),
+            mode: z.string().optional(), visibility: z.string().optional(), scope: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            rubricThresholds: z.object({
+                fit: z.number().optional(), form: z.number().optional(),
+                truth: z.number().optional(), taste: z.number().optional(),
+            }).optional(),
+        }),
+        response: z.object({ ok: z.literal(true), sid: z.string(), scope: z.string() }),
+        effect: "ask",
+    }),
+    // ── loop ──
+    "loop:close": receiver({
+        receiver: "loop:close",
+        summary: "Close a loop session with an outcome",
+        request: z.object({
+            session: z.string(),
+            outcome: z.enum(["result", "timeout", "dissolved", "failure"]),
+            rubric: z.number().optional(),
+            reason: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.literal(true), stages: z.array(z.unknown()),
+            highways: z.array(z.object({ path: z.string(), strength: z.number(), resistance: z.number(), net: z.number() })),
+        }),
+        effect: "ask",
+    }),
+    // ── reads (free · idempotent) ──
+    "signals:list": receiver({
+        receiver: "signals:list",
+        summary: "List recent signals",
+        request: z.object({
+            limit: z.number().optional(), since: z.number().optional(),
+            from: z.number().optional(), to: z.number().optional(),
+        }),
+        response: z.array(z.object({
+            id: z.string(), from: z.string(), to: z.string(), skill: z.string().optional(),
+            outcome: z.enum(["success", "failure", "timeout"]), revenue: z.number(), ts: z.number(),
+        })),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "stats:current": receiver({
+        receiver: "stats:current",
+        summary: "Current world stats — units, skills, highways, revenue, signals",
+        request: z.object({}),
+        response: StatsSchema,
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "dashboard:usage": receiver({
+        receiver: "dashboard:usage",
+        summary: "Caller's plan usage — calls, agents, limits",
+        request: z.object({}),
+        response: z.object({
+            tier: z.string(), calls_this_month: z.number(), agents_count: z.number(),
+            api_limit: z.number(), agent_limit: z.number(), loops: z.array(z.string()),
+            highways_count: z.number(), upgrade_url: z.string(),
+        }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "world:state": receiver({
+        receiver: "world:state",
+        summary: "Full world snapshot — units, edges, highways, tags, stats",
+        request: z.object({}),
+        response: z.object({}).passthrough(),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    // ════════════════════════════════════════════════════════════════════════
+    // C5 — meta: the self-describing surface. Pure reads an agent uses to learn
+    // the catalog, a receiver's schema, and its own memory before acting. The
+    // catalog/schema handlers are pure projections over RECEIVERS (see meta.ts).
+    // ════════════════════════════════════════════════════════════════════════
+    "meta:catalog": receiver({
+        receiver: "meta:catalog",
+        summary: "List every receiver the caller can use (with cost/reversibility/settlement), or a goal's recipe",
+        request: z.object({ goal: z.enum(["spine", "build", "trade", "transact"]).optional() }),
+        response: z.union([
+            z.array(z.object({
+                receiver: z.string(), summary: z.string(), effect: z.enum(["signal", "ask"]),
+                auth: z.string().optional(), reversible: z.boolean().optional(),
+                settles: z.enum(["none", "offchain", "onchain"]).optional(),
+            }).passthrough()),
+            z.object({ goal: z.string(), recipe: z.array(z.string()) }),
+        ]),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "meta:schema": receiver({
+        receiver: "meta:schema",
+        summary: "JSON Schema for one receiver's request + response — read it before you call",
+        request: z.object({ receiver: z.string() }),
+        response: z.object({
+            receiver: z.string(), summary: z.string(),
+            request: z.unknown(), response: z.unknown(),
+        }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "meta:recall": receiver({
+        receiver: "meta:recall",
+        summary: "Recall the caller's hypotheses (memory), optionally filtered by a search term",
+        request: z.object({ match: z.string().optional(), limit: z.number().optional() }),
+        response: z.object({
+            hypotheses: z.array(z.object({
+                hid: z.string(), claim: z.string(), status: z.string(), confidence: z.number().nullable(),
+            })),
+        }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    // ── actor discovery + messaging ──────────────────────────────────────────
+    "actors:find": receiver({
+        receiver: "actors:find",
+        summary: "Find agents on the marketplace by name fragment or skill — marketplace discovery only",
+        request: z.object({
+            // human is excluded: personal names/emails are PII, not marketplace data.
+            type: z.enum(["agent", "world"]).optional(),
+            search: z.string().max(100).optional(),
+            skill: z.string().max(100).optional(),
+            limit: z.number().max(100).optional(),
+        }),
+        response: z.object({
+            actors: z.array(z.object({ uid: z.string(), name: z.string(), type: z.string() })),
+            total: z.number(),
+        }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
+    "peer:message": receiver({
+        receiver: "peer:message",
+        summary: "Send an async message to another agent's inbox — instant store, no LLM, no streaming",
+        request: z.object({ to: z.string(), content: z.string(), from: z.string().optional() }),
+        response: z.object({ ok: z.boolean(), id: z.string().optional(), ts: z.number().optional(), to: z.string().optional(), from: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", idempotent: false,
+    }),
+    "chat:send": receiver({
+        receiver: "chat:send",
+        summary: "Send a message to a group the caller is a member of — sender is always the authenticated caller",
+        request: z.object({
+            group: z.string(),
+            text: z.string(),
+            // sender is NOT in the schema — derived server-side from the authenticated caller uid.
+            slug: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), reply: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", auth: "member",
+    }),
+};
+/**
+ * RECIPES — the four agent journeys as typed, ordered receiver sequences (C6).
+ * Each entry is `readonly ReceiverName[]`, so a typo or a renamed receiver is a
+ * compile error. `meta:catalog?goal=` returns one of these; the MCP server
+ * groups its tools by them. See `plans/agent-first-spec.md`.
+ */
+export const RECIPES = {
+    /** Onboard: become an actor → mint a key → join a group → declare capability. */
+    spine: ["auth:agent", "world:create-key", "groups:join", "agents:sync"],
+    /** Build a world: workspace → group → actor → thing. */
+    build: ["world:create-workspace", "world:create-group", "world:create-actor", "world:create-thing"],
+    /** Trade: list a capability → browse the market → hire → pay. */
+    trade: ["capabilities:publish", "market:list", "market:hire", "pay:weight"],
+    /** Transact: post a bounty → settle it onchain. */
+    transact: ["market:bounty", "pay:weight"],
+};
+//# sourceMappingURL=receivers.js.map