@oneie/sdk 0.9.0 → 0.11.0

package/dist/receivers.js

@@ -0,0 +1,1441 @@
+import { z } from "zod";
+import { AgentActionResponseSchema, AgentStatusResponseSchema, CapabilityItemSchema, PayResponseSchema, RegisterResponseSchema, StatsSchema, StepKind, WorkflowDiffSchema, } 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 ──
+    "agent:enroll": receiver({
+        receiver: "agent:enroll",
+        summary: "Self-enroll as an agent — mint identity + API key with no prior session",
+        request: z.object({ name: z.string(), capabilities: z.array(z.string()).optional() }),
+        response: z.object({ ok: z.literal(true), actorId: z.string(), slug: z.string(), apiKey: z.string(), credits: z.number() }),
+        effect: "ask", auth: "public", reversible: false, idempotent: false,
+    }),
+    "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:update-contact": receiver({
+        receiver: "world:update-contact",
+        summary: "Update an actor's contact/profile attributes — identity, contact details, professional, personal, CRM metrics",
+        request: z.object({
+            aid: z.string(),
+            // identity
+            name: z.string().optional(),
+            firstName: z.string().optional(),
+            lastName: z.string().optional(),
+            nickname: z.string().optional(),
+            title: z.string().optional(),
+            avatar: z.string().optional(),
+            bio: z.string().optional(),
+            // contact
+            email: z.string().optional(),
+            phone: z.string().optional(),
+            website: z.string().optional(),
+            // professional
+            jobTitle: z.string().optional(),
+            company: z.string().optional(),
+            department: z.string().optional(),
+            role: z.string().optional(),
+            // personal
+            birthday: z.string().optional(),
+            gender: z.string().optional(),
+            nationality: z.string().optional(),
+            timezone: z.string().optional(),
+            // address
+            street: z.string().optional(),
+            city: z.string().optional(),
+            region: z.string().optional(),
+            postcode: z.string().optional(),
+            country: z.string().optional(),
+            // crm
+            lifecycle: z.string().optional(),
+            source: z.string().optional(),
+            // numeric crm metrics
+            value: z.number().optional(),
+            fitScore: z.number().optional(),
+            nps: z.number().optional(),
+            csat: z.number().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 (PAT) for an actor you own; scope is capped at the actor's role, optional expiresIn (seconds)",
+        request: z.object({
+            actor: z.string(),
+            scope: z.enum(["read", "write", "admin"]).optional(),
+            label: z.string().optional(),
+            expiresIn: z.number().int().positive().optional(),
+        }),
+        // Self-service: any authenticated member can mint a key for an actor they own
+        // (requireActorOwner is the gate). The scope ceiling prevents privilege escalation.
+        response: z.object({ key: z.string(), keyId: z.string(), scope: z.string() }),
+        effect: "ask", auth: "member", scope: "write", reversible: false,
+        examples: [{ actor: "01ABC", scope: "write", label: "cli" }],
+    }),
+    "world:list-keys": receiver({
+        receiver: "world:list-keys",
+        summary: "List active API keys (metadata only — never the secret) for an actor you own",
+        request: z.object({ actor: z.string() }),
+        response: z.object({
+            keys: z.array(z.object({
+                keyId: z.string(),
+                label: z.string().nullable(),
+                scope: z.string(),
+                createdAt: z.number(),
+                validTo: z.number().nullable(),
+            })),
+        }),
+        effect: "ask", auth: "member", scope: "read", cost: "free", idempotent: true,
+    }),
+    "world:revoke-key": receiver({
+        receiver: "world:revoke-key",
+        summary: "Revoke an API key",
+        request: z.object({ keyId: z.string() }), response: ok, effect: "ask", auth: "member", scope: "write", 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 killed (C7): Better Auth handles all human auth; signal/ask pipeline returns dissolved
+    "auth:sign-out": receiver({
+        receiver: "auth:sign-out",
+        summary: "End the current session",
+        request: z.object({}),
+        response: ok,
+        effect: "signal", idempotent: true,
+    }),
+    // board:join killed (C7): no resolver, no route, no caller
+    // agency:push:complete killed (C7): no resolver, no route, no caller
+    // agency:friction killed (C7): no resolver, no route, no caller
+    // ── 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:bridge killed (C7): no resolver, no route, no caller
+    // ── 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 killed (C7): no resolver, no route, no caller
+    // ── 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 (A2A negotiation, C2) ──
+    "market:offer": receiver({
+        receiver: "market:offer",
+        summary: "Buyer creates a Deal at OFFER stage — initiates A2A negotiation",
+        request: z.object({
+            id: z.string().uuid().optional(),
+            seller: z.string().min(1),
+            skill: z.string().min(1),
+            price: z.number().nonnegative(),
+            currency: z.string().default("credits"),
+            deadline: z.string().datetime(),
+        }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: true, idempotent: false,
+    }),
+    "market:counter": receiver({
+        receiver: "market:counter",
+        summary: "Seller revises deal terms — stays at OFFER, bumps version",
+        request: z.object({
+            dealId: z.string().min(1),
+            price: z.number().nonnegative().optional(),
+            deadline: z.string().datetime().optional(),
+            skill: z.string().optional(),
+        }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: true, idempotent: false,
+    }),
+    "market:accept": receiver({
+        receiver: "market:accept",
+        summary: "Buyer accepts deal — OFFER → ESCROW",
+        request: z.object({ dealId: z.string().min(1) }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    "market:reject": receiver({
+        receiver: "market:reject",
+        summary: "Buyer rejects deal — OFFER → FADE",
+        request: z.object({ dealId: z.string().min(1) }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    "market:deliver": receiver({
+        receiver: "market:deliver",
+        summary: "Seller delivers work — EXECUTE → VERIFY",
+        request: z.object({ dealId: z.string().min(1), result: z.record(z.string(), z.unknown()).optional() }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    "market:verify": receiver({
+        receiver: "market:verify",
+        summary: "Buyer scores delivered work — VERIFY → SETTLE (≥0.65) or DISPUTE (<0.65)",
+        request: z.object({
+            dealId: z.string().min(1),
+            fit: z.number().min(0).max(1),
+            form: z.number().min(0).max(1),
+            truth: z.number().min(0).max(1),
+            taste: z.number().min(0).max(1),
+        }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }), scores: z.object({ fit: z.number(), form: z.number(), truth: z.number(), taste: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    "market:settle": receiver({
+        receiver: "market:settle",
+        summary: "Release escrow payment — SETTLE → RECEIPT",
+        request: z.object({ dealId: z.string().min(1) }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    "market:dispute": receiver({
+        receiver: "market:dispute",
+        summary: "Escalate an active deal to DISPUTE — either party may call",
+        request: z.object({ dealId: z.string().min(1) }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    "market:escrow": receiver({
+        receiver: "market:escrow",
+        summary: "Buyer locks payment via pay.one.ie — ESCROW → EXECUTE on confirmed tx",
+        request: z.object({ dealId: z.string().min(1) }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }), escrowRef: z.string() }),
+            z.object({ ok: z.literal(false), error: z.string(), deal: z.object({ id: z.string(), stage: z.string() }).optional() }),
+        ]),
+        effect: "ask", auth: "required", reversible: false, idempotent: false,
+    }),
+    // ── 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:claim": receiver({
+        receiver: "market:claim",
+        summary: "Claim an open bounty — atomically marks it picked and binds the claimant",
+        request: z.object({ bountyId: z.string() }),
+        response: z.union([
+            z.object({ ok: z.literal(true), bountyId: z.string(), claimantUid: z.string() }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", cost: "free", reversible: false, idempotent: false,
+    }),
+    "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:close killed (C7): no resolver, no route, no caller
+    // ── 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",
+    }),
+    // ── booking — one calendar, two doors (text/booking-plan.md §5) ───────────────
+    // Both public-bookable: a customer with no account books a slot. The provider
+    // side (configure a service) is the separate, gated booking:configure.
+    "booking:list-slots": receiver({
+        receiver: "booking:list-slots",
+        summary: "List open slots for a workspace's service on a date (or next open days)",
+        request: z.object({
+            slug: z.string(), // provider workspace
+            service: z.string().optional(), // service_id; omitted → the workspace's first active
+            date: z.string().optional(), // 'YYYY-MM-DD'; omitted → next N open days
+            days: z.number().int().min(1).max(14).optional(), // window size when date omitted
+        }),
+        response: z.object({
+            service: z.object({
+                service_id: z.string(), name: z.string(), duration_min: z.number(),
+                price: z.number(), currency: z.string(),
+            }).nullable(),
+            slots: z.array(z.object({ date: z.string(), times: z.array(z.string()) })), // CalendarCard shape
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: true, simulatable: false,
+        examples: [{ slug: "clearwater", date: "2026-06-10" }],
+    }),
+    "booking:create": receiver({
+        receiver: "booking:create",
+        summary: "Hold a slot for a customer; returns a ref and a payment intent when price > 0",
+        request: z.object({
+            slug: z.string(),
+            service: z.string(),
+            slotDate: z.string(), // 'YYYY-MM-DD'
+            slotTime: z.string(), // 'HH:MM' 24h, slot start
+            customer: z.object({ name: z.string(), email: z.string().email().optional() }),
+            paymentRail: z.enum(["stripe", "sui"]).optional(), // resolver overrides by caller kind
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            ref: z.string().optional(),
+            status: z.enum(["pending", "confirmed"]).optional(),
+            paymentRail: z.enum(["stripe", "sui"]).nullable().optional(),
+            paymentIntent: z.object({ clientSecret: z.string(), amount: z.number() }).optional(), // human, price>0
+            escrow: z.object({ escrowId: z.string(), bounty: z.number(), deadline: z.string() }).optional(), // agent
+            error: z.string().optional(), // 'slot_taken' | 'closed' | 'unknown_service'
+        }),
+        effect: "ask", cost: "variable", settles: "offchain", reversible: false,
+        simulatable: true, idempotent: true, // idempotencyKey dedupes a retried hold
+        examples: [{ slug: "clearwater", service: "svc_x", slotDate: "2026-06-10",
+                slotTime: "15:00", customer: { name: "Sarah", email: "s@ex.com" } }],
+    }),
+    // booking:configure — the ONE provider-gated booking receiver (§10). Unlike the
+    // two public-bookable receivers above, the resolver re-walks
+    // can(actor, group, "manage_clients") server-side and UPSERTs only the caller's
+    // own service rows. NOT public-bookable.
+    "booking:configure": receiver({
+        receiver: "booking:configure",
+        summary: "Provider-gated: create or update a bookable service (hours, slot length, price, currency, tz, active)",
+        request: z.object({
+            slug: z.string(), // the workspace; the write scope (re-walked)
+            actorId: z.string().optional(), // re-walk subject (gateway-forwarded)
+            service: z.string().optional(), // service_id to update; omitted → create
+            name: z.string(),
+            duration_min: z.number().int().positive(),
+            price: z.number().int().nonnegative().optional(),
+            currency: z.string().optional(),
+            hours_json: z.array(z.array(z.object({ start: z.string(), end: z.string() }))), // 7 entries, 0=Sun
+            tz: z.string().optional(),
+            active: z.boolean().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), service_id: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", idempotent: true, reversible: true, auth: "manage_clients",
+        examples: [{ slug: "clearwater", name: "Consultation", duration_min: 30, price: 4000, currency: "gbp",
+                hours_json: [[], [{ start: "09:00", end: "17:00" }], [], [], [], [], []] }],
+    }),
+    // booking:list-bookings — the provider's own appointment list for a month (§6
+    // web surface). Tenant-private read: the resolver scopes to the authenticated
+    // owner, never the body slug, so a caller only ever sees their own workspace.
+    "booking:list-bookings": receiver({
+        receiver: "booking:list-bookings",
+        summary: "Provider-gated: list a workspace's bookings for a month (customer, time, service, status)",
+        request: z.object({
+            slug: z.string(), // workspace (informational; gate re-scopes to caller)
+            month: z.string().optional(), // 'YYYY-MM'; omitted → current month
+        }),
+        response: z.object({
+            bookings: z.array(z.object({
+                id: z.string(), ref: z.string(), service_name: z.string(),
+                slot_date: z.string(), slot_time: z.string(),
+                customer_name: z.string(), status: z.string(),
+            })),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: true, auth: "manage_clients",
+        examples: [{ slug: "clearwater", month: "2026-06" }],
+    }),
+    // booking:cancel — provider dissolves a booking by ref, releasing the slot
+    // immediately (the partial unique index drops dissolved rows from scope, §9).
+    // Tenant-private write: scoped to the authenticated owner. Idempotent.
+    "booking:cancel": receiver({
+        receiver: "booking:cancel",
+        summary: "Provider-gated: dissolve a booking by ref, releasing the slot",
+        request: z.object({
+            slug: z.string(),
+            ref: z.string(),
+        }),
+        response: z.object({ ok: z.boolean(), error: z.string().optional() }),
+        effect: "ask", cost: "free", idempotent: true, reversible: false, auth: "manage_clients",
+        examples: [{ slug: "clearwater", ref: "CLE-2026-4821" }],
+    }),
+    // ── workflows — define an SOP, run it, watch it learn (text/workflows-plan.md) ──
+    // Every workflow op is a typed receiver. No new REST routes. apply-diff is
+    // simulatable: simulate=true validates the WorkflowDiff (incl. DAG acyclicity)
+    // and commits nothing — the chat-authoring preview path.
+    "workflow:list": receiver({
+        receiver: "workflow:list",
+        summary: "List a workspace's workflows (D1 mirror); pass templates=true for the public SOP catalog",
+        request: z.object({
+            slug: z.string().optional(),
+            templates: z.boolean().optional(),
+        }),
+        response: z.object({
+            workflows: z.array(z.object({
+                id: z.string(), name: z.string(), description: z.string().optional(), step_count: z.number(),
+                status: z.string(), last_run_status: z.string().nullable(),
+            })),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: true, simulatable: false, auth: "view_workflows",
+        examples: [{ slug: "acme" }, { templates: true }],
+    }),
+    "workflow:get": receiver({
+        receiver: "workflow:get",
+        summary: "Fetch one workflow's full graph — steps (kind, config, position) and edges (with conditions)",
+        request: z.object({ workflowId: z.string() }),
+        response: z.object({
+            id: z.string(), name: z.string(), status: z.string(),
+            steps: z.array(z.object({
+                id: z.string(), kind: StepKind, name: z.string(),
+                config: z.string(), position: z.string().optional(),
+            })),
+            edges: z.array(z.object({
+                source: z.string(), target: z.string(),
+                strength: z.number(), resistance: z.number(),
+                condition: z.string().optional(),
+            })),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: true, simulatable: false, auth: "view_workflows",
+        examples: [{ workflowId: "wf_abc" }],
+    }),
+    "workflow:runs": receiver({
+        receiver: "workflow:runs",
+        summary: "List recent runs of a workflow (D1 workflow_run) for the monitor + history surfaces",
+        request: z.object({ workflowId: z.string(), runId: z.string().optional(), limit: z.number().int().min(1).max(200).optional() }),
+        response: z.object({
+            runs: z.array(z.object({
+                id: z.string(), status: z.string(),
+                started_at: z.number(), finished_at: z.number().nullable(),
+            })),
+            events: z.array(z.object({
+                step_id: z.string(), kind: z.string(), status: z.string().nullable(),
+                latency_ms: z.number().nullable(), at: z.number(),
+            })).optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: true, simulatable: false, auth: "view_workflows",
+        examples: [{ workflowId: "wf_abc", limit: 20 }, { workflowId: "wf_abc", runId: "run_1" }],
+    }),
+    "workflow:create": receiver({
+        receiver: "workflow:create",
+        summary: "Create a blank workflow (group group-type=workflow) — optionally cloned from a template",
+        request: z.object({
+            slug: z.string().optional(),
+            name: z.string(),
+            description: z.string().optional(), // defaults from the cloned template
+            fromTemplate: z.string().optional(),
+            simulate: z.boolean().optional(),
+        }),
+        response: z.object({ id: z.string(), workflowId: z.string() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: false, simulatable: true,
+        auth: "manage_workflows",
+        examples: [{ name: "Client Onboarding" }, { name: "demo", simulate: true }],
+    }),
+    "workflow:apply-diff": receiver({
+        receiver: "workflow:apply-diff",
+        summary: "Apply a WorkflowDiff (add/remove/connect/disconnect/update). simulate=true validates the DAG without persisting",
+        request: z.object({
+            workflowId: z.string(),
+            diff: WorkflowDiffSchema,
+            simulate: z.boolean().optional(),
+            version: z.number().int().optional(), // optimistic lock — stale → conflict
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            stepCount: z.number().optional(),
+            idMap: z.record(z.string(), z.string()).optional(), // tempId → persisted id
+            error: z.string().optional(), // 'cycle_detected' | 'conflict' | 'invalid_diff'
+        }),
+        effect: "ask", cost: "free", reversible: true, idempotent: false, simulatable: true,
+        auth: "manage_workflows",
+        examples: [{ workflowId: "wf_abc", diff: { add: [{ tempId: "s1", kind: "trigger", name: "On signup", config: "{}" }] }, simulate: true }],
+    }),
+    "workflow:run": receiver({
+        receiver: "workflow:run",
+        summary: "Start a run — spawns the WorkflowRun DO, executes each step, marks path strength on traversed edges",
+        request: z.object({
+            workflowId: z.string(),
+            triggerPayload: z.record(z.string(), z.unknown()).optional(),
+            idempotencyKey: z.string().optional(),
+        }),
+        response: z.object({ runId: z.string(), status: z.string(), error: z.string().optional() }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: true, simulatable: false, settles: "none",
+        auth: "manage_workflows",
+        examples: [{ workflowId: "wf_abc" }],
+    }),
+    "human:resolve": receiver({
+        receiver: "human:resolve",
+        summary: "Resolve a suspended human step — carries { runId, stepId, decision | formPayload } to the run DO",
+        request: z.object({
+            runId: z.string(),
+            stepId: z.string(),
+            decision: z.enum(["approved", "rejected"]).optional(),
+            formPayload: z.record(z.string(), z.unknown()).optional(),
+            // System callers (a Telegram/Discord button via channels) attest the
+            // workspace; an authenticated session's slug always wins over this. The
+            // `slug` is trusted ONLY with a valid `attestation` — HMAC(IDENTITY_SECRET,
+            // "human:resolve:<runId>:<stepId>:<slug>") that only channels can mint after
+            // it re-walks the tapper's authority. Without it, slug is ignored.
+            slug: z.string().optional(),
+            attestation: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), status: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", idempotent: true, simulatable: false, auth: "manage_workflows",
+        examples: [{ runId: "run_1", stepId: "s2", decision: "approved" }],
+    }),
+    "checkout:create": receiver({
+        receiver: "checkout:create",
+        summary: "The `sell` step's binding — mint a Connect checkout session for the buyer, stamping { runId, stepId } into session metadata so checkout:resume can wake the run",
+        request: z.object({
+            workspace: z.string(),
+            ppid: z.string(),
+            // Set by the executor when a `sell` step dispatches this — the run's resume coordinates.
+            runId: z.string().optional(),
+            stepId: z.string().optional(),
+        }),
+        response: z.object({
+            clientSecret: z.string().nullable().optional(),
+            sessionId: z.string().optional(),
+            applicationFeeAmount: z.number().optional(),
+            stripeAccount: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: false, simulatable: false, settles: "offchain",
+        auth: "manage_workflows",
+        examples: [{ workspace: "acme", ppid: "pr_1" }],
+    }),
+    "checkout:resume": receiver({
+        receiver: "checkout:resume",
+        summary: "Wake a run suspended at a `sell` step — the storefront webhook fires this on checkout.session.completed with the (runId, stepId) it stamped at create. Sibling of human:resolve.",
+        request: z.object({
+            runId: z.string(),
+            stepId: z.string(),
+            // The run's own workspace (from the session metadata the webhook reads); the
+            // runId is the resume capability, re-validated against the parked run server-side.
+            slug: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), status: z.string().optional(), error: z.string().optional() }),
+        effect: "signal", cost: "free", idempotent: true, simulatable: false, auth: "manage_workflows",
+        examples: [{ runId: "run_1", stepId: "s2", slug: "acme" }],
+    }),
+    "human:notify": receiver({
+        receiver: "human:notify",
+        summary: "Post a channel-shaped approval into a run's conversation when it suspends at a human step — web card · Telegram inline keys · Discord components. Sibling of chat:send.",
+        request: z.object({
+            runId: z.string(),
+            stepId: z.string(),
+            stepName: z.string().optional(),
+            workflowName: z.string().optional(),
+            group: z.string().optional(), // conversation group; falls back to the run's started_by
+        }),
+        response: z.object({ ok: z.boolean(), group: z.string().optional(), error: z.string().optional() }),
+        effect: "signal", cost: "free", idempotent: true, simulatable: false, auth: "manage_workflows",
+        examples: [{ runId: "run_1", stepId: "s2", stepName: "Approve contract" }],
+    }),
+    "workflow:stop": receiver({
+        receiver: "workflow:stop",
+        summary: "Park a live run at its current step (status → paused); preserves the resume cursor so human:resolve or a re-run continues it",
+        request: z.object({ runId: z.string() }),
+        response: z.object({ ok: z.boolean(), status: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, simulatable: false, auth: "manage_workflows",
+        examples: [{ runId: "run_1" }],
+    }),
+    "workflow:trigger": receiver({
+        receiver: "workflow:trigger",
+        summary: "Fire every workspace workflow whose trigger step matches a channel source (e.g. webhook:telegram)",
+        request: z.object({
+            source: z.string(),
+            slug: z.string().optional(),
+            triggerPayload: z.record(z.string(), z.unknown()).optional(),
+        }),
+        response: z.object({ ok: z.boolean(), started: z.number(), runIds: z.array(z.string()) }),
+        effect: "signal", cost: "variable", reversible: false, idempotent: false, simulatable: false, auth: "manage_workflows",
+        examples: [{ source: "webhook:telegram", slug: "acme" }],
+    }),
+    "workflow:delete": receiver({
+        receiver: "workflow:delete",
+        summary: "Delete a workflow and all its runs, steps, and edges",
+        request: z.object({ workflowId: z.string() }),
+        response: z.object({ ok: z.boolean(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "manage_workflows",
+        examples: [{ workflowId: "wf_abc" }],
+    }),
+    "workflow:update": receiver({
+        receiver: "workflow:update",
+        summary: "Rename a workflow or change its status (draft|active|paused)",
+        request: z.object({ workflowId: z.string(), name: z.string().optional(), status: z.enum(["draft", "active", "paused"]).optional() }),
+        response: z.object({ ok: z.boolean(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "manage_workflows",
+        examples: [{ workflowId: "wf_abc", name: "Renamed Workflow" }, { workflowId: "wf_abc", status: "paused" }],
+    }),
+    // ── The autonomy ladder's leaf runners — a workflow skill/agent step compiles
+    //    to one of these (workflow-executor.ts stepBinding). Both proxy to the
+    //    channels runtime; web owns the catalog + tenant authority (workflows-lock C2/C3).
+    "skills:list": receiver({
+        receiver: "skills:list",
+        summary: "List the caller's workspace skill catalog (R2) — powers the canvas SkillPicker",
+        request: z.object({}),
+        response: z.object({
+            skills: z.array(z.object({ name: z.string(), size: z.number() })),
+        }),
+        effect: "ask", cost: "free", idempotent: true, simulatable: false, auth: "view_workflows",
+        examples: [{}],
+    }),
+    "skill:run": receiver({
+        receiver: "skill:run",
+        summary: "Run a workspace skill — loads its body from R2, runs one bounded turn via channels, returns { text }",
+        request: z.object({ skill: z.string() }).catchall(z.unknown()), // extra keys = the skill's input
+        response: z.object({ ok: z.boolean(), text: z.string().optional(), skill: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: false, simulatable: false, settles: "none", auth: "manage_workflows",
+        examples: [{ skill: "copywriting", topic: "launch" }],
+    }),
+    "agent:run": receiver({
+        receiver: "agent:run",
+        summary: "Invoke a bound actor (optionally skill-constrained) for one bounded turn via channels; returns { text }",
+        request: z.object({
+            actorId: z.string(),
+            skill: z.string().optional(),
+            instructions: z.string().optional(),
+        }).catchall(z.unknown()), // extra keys = the agent's input
+        response: z.object({ ok: z.boolean(), text: z.string().optional(), actorId: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: false, simulatable: false, settles: "none", auth: "manage_workflows",
+        examples: [{ actorId: "one:support", skill: "support", instructions: "Reply kindly." }],
+    }),
+    // ── video — room provisioning, sessions, invitations, recording (text/video-live-improve-plan.md) ──
+    // Seven receivers already ship in receiver-resolvers.ts. These declarations expose
+    // them to typed ask<R>/signal<R> callers, the MCP surface, and edge validation.
+    // Four new receivers (quick-room, join-event, start-recording, start-stream) are
+    // declared here and implemented in the same W1 batch.
+    "video:create-room": receiver({
+        receiver: "video:create-room",
+        summary: "Create a 100ms video room for a workspace; returns the room slug and URL",
+        request: z.object({
+            workspace: z.string(),
+            roomSlug: z.string(),
+            name: z.string(),
+            description: z.string().optional(),
+            type: z.enum(["meeting", "classroom", "webinar"]).optional(),
+            region: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            room: z.object({
+                slug: z.string(), name: z.string(), description: z.string(),
+                type: z.string(), hmsRoomId: z.string(), url: z.string(),
+            }).optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", roomSlug: "algebra-101", name: "Algebra 101", type: "classroom" }],
+    }),
+    "video:delete-room": receiver({
+        receiver: "video:delete-room",
+        summary: "Disable a video room and its 100ms counterpart; room is no longer joinable",
+        request: z.object({ workspace: z.string(), roomSlug: z.string() }),
+        response: z.object({ ok: z.boolean(), error: z.string().optional() }),
+        effect: "ask", cost: "free", idempotent: true, reversible: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", roomSlug: "algebra-101" }],
+    }),
+    "video:contact-call": receiver({
+        receiver: "video:contact-call",
+        summary: "Provision a one-to-one video room for a contact; links the room thread to the contact CRM record",
+        request: z.object({
+            workspace: z.string(),
+            actorId: z.string(),
+            name: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            roomSlug: z.string().optional(),
+            threadId: z.string().nullable().optional(),
+            guestJoinUrl: z.string().optional(),
+            hostJoinUrl: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", actorId: "actor_123", name: "Call with Sarah" }],
+    }),
+    "video:invite": receiver({
+        receiver: "video:invite",
+        summary: "Generate a tracked /go/ join link for an actor into an existing room",
+        request: z.object({
+            workspace: z.string(),
+            roomSlug: z.string(),
+            actorId: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            goUrl: z.string().optional(),
+            destination: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", roomSlug: "algebra-101", actorId: "actor_456" }],
+    }),
+    "video:schedule-webinar": receiver({
+        receiver: "video:schedule-webinar",
+        summary: "Create a webinar room and send tracked invite links to N contacts in one call",
+        request: z.object({
+            workspace: z.string(),
+            name: z.string().optional(),
+            actorIds: z.array(z.string()).min(1).max(500),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            roomUrl: z.string().optional(),
+            invited: z.number().optional(),
+            links: z.array(z.object({ actorId: z.string(), goUrl: z.string() })).optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", name: "Product Launch", actorIds: ["actor_1", "actor_2"] }],
+    }),
+    "video:create-session": receiver({
+        receiver: "video:create-session",
+        summary: "Create a video session with host + guest tracked join links; optionally schedules the call",
+        request: z.object({
+            workspace: z.string(),
+            roomSlug: z.string(),
+            name: z.string(),
+            type: z.enum(["meeting", "classroom", "webinar"]).optional(),
+            region: z.string().optional(),
+            guestActorId: z.string().optional(),
+            scheduledAt: z.number().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            room: z.object({ slug: z.string(), hmsRoomId: z.string(), url: z.string() }).optional(),
+            hostJoinUrl: z.string().optional(),
+            guestJoinUrl: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", roomSlug: "consult-abc", name: "Consultation", guestActorId: "actor_789" }],
+    }),
+    "video:summary": receiver({
+        receiver: "video:summary",
+        summary: "Run an AI summary of a call transcript and append it as a system message on the room thread",
+        request: z.object({
+            threadId: z.string(),
+            transcript: z.string(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            threadId: z.string().optional(),
+            skipped: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "variable", idempotent: false, auth: "manage_clients",
+        examples: [{ threadId: "thr_abc", transcript: "Host: Hello... Guest: Hi..." }],
+    }),
+    "video:quick-room": receiver({
+        receiver: "video:quick-room",
+        summary: "Ad-hoc video room from any chat thread — creates the room, sends the join link into the thread",
+        request: z.object({
+            workspace: z.string(),
+            threadId: z.string().optional(),
+            name: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            roomSlug: z.string().optional(),
+            guestJoinUrl: z.string().optional(),
+            hostJoinUrl: z.string().optional(),
+            threadId: z.string().nullable().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", threadId: "thr_xyz", name: "Quick sync" }],
+    }),
+    "video:join-event": receiver({
+        receiver: "video:join-event",
+        summary: "Record a peer join event for tracking and lifecycle; public — called from the /go/ link handler",
+        request: z.object({
+            workspace: z.string(),
+            roomSlug: z.string(),
+            role: z.string().optional(),
+            actorId: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), error: z.string().optional() }),
+        effect: "signal", cost: "free", idempotent: true,
+        examples: [{ workspace: "acme", roomSlug: "consult-abc", role: "guest" }],
+    }),
+    "video:start-recording": receiver({
+        receiver: "video:start-recording",
+        summary: "Start cloud recording for an active room via 100ms REST; inserts a video_recordings row",
+        request: z.object({ workspace: z.string(), roomSlug: z.string() }),
+        response: z.object({
+            ok: z.boolean(),
+            recordingId: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", roomSlug: "algebra-101" }],
+    }),
+    "video:start-stream": receiver({
+        receiver: "video:start-stream",
+        summary: "Start an HLS live stream for a room; returns the playback URL when the stream is ready",
+        request: z.object({
+            workspace: z.string(),
+            roomSlug: z.string(),
+            hlsConfig: z.record(z.string(), z.unknown()).optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            hlsUrl: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", idempotent: false, auth: "manage_clients",
+        examples: [{ workspace: "acme", roomSlug: "product-launch" }],
+    }),
+    // connect:channel — token-paste connect for a channel (Connect plan C7). The
+    // typed contract over the shipped /api/connect/telegram route: the caller pastes
+    // a channel credential, web verifies it (getMe), points the webhook, then hands
+    // the raw secret to channels' /connect sink under the owner gate. SECURITY: the
+    // token rides the REQUEST only; the response NEVER echoes it. effect:ask,
+    // auth:manage_clients re-walked server-side off locals.slug (never body actorId).
+    "connect:channel": receiver({
+        receiver: "connect:channel",
+        summary: "Connect a channel (e.g. telegram) by pasting its bot token; verifies, sets the webhook, seals the credential under the owner gate",
+        request: z.object({
+            channel: z.string(), // 'telegram' (token-paste path)
+            token: z.string(), // the bot credential — request-only, never returned/logged
+            slug: z.string().optional(), // workspace; gate re-scopes to the authenticated owner
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            status: z.string().optional(), // 'active' | 'updated' from the channels sink
+            account: z.string().optional(), // public handle (e.g. bot username) — never the token
+            error: z.string().optional(), // 'invalid token' | 'unauthorized' | 'duplicate'
+        }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "manage_clients",
+        examples: [{ channel: "telegram", token: "<bot-token>" }],
+    }),
+    // connect:status — list the workspace's connected channels (Connect plan C8).
+    // Read-only contract over /api/connect/status: rows come from the `connection`
+    // table scoped to the authenticated owner (locals.slug — never a body slug).
+    // SECURITY: the response carries channel + public account id + status only;
+    // cred_ref and webhook_secret never leave the server.
+    "connect:status": receiver({
+        receiver: "connect:status",
+        summary: "List connected channels for the workspace — channel, account, status, runtime; never the credential",
+        request: z.object({}),
+        response: z.object({
+            ok: z.boolean(),
+            connections: z
+                .array(z.object({
+                channel: z.string(), // 'telegram' | 'slack' | 'discord' | 'email'
+                account: z.string(), // external_account_id (bot id / team id / inbound address)
+                status: z.string(), // 'active' | 'revoked'
+                runtime: z.string(), // 'webhook' | 'socket'
+                connected_at: z.number(), // unix epoch seconds
+            }))
+                .optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "manage_clients",
+        examples: [{}],
+    }),
+    // ── Broadcast (newsletter) ────────────────────────────────────────────────
+    "broadcast:create": receiver({
+        receiver: "broadcast:create",
+        summary: "Create a broadcast draft — subject, body_md, audience_tag, channel",
+        request: z.object({ workspace: z.string(), subject: z.string().optional(), body_md: z.string().optional(), audience_tag: z.string().optional(), channel: z.enum(["email", "sms", "whatsapp"]).optional() }),
+        response: z.object({ broadcastId: z.string() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: false, auth: "write",
+    }),
+    "broadcast:update": receiver({
+        receiver: "broadcast:update",
+        summary: "Update a broadcast draft — subject, body, audience, schedule",
+        request: z.object({ workspace: z.string(), broadcastId: z.string(), subject: z.string().optional(), body_md: z.string().optional(), audience_tag: z.string().optional(), scheduled_at: z.number().optional() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "write",
+    }),
+    "broadcast:list": receiver({
+        receiver: "broadcast:list",
+        summary: "List broadcasts for a workspace with status and sent_at",
+        request: z.object({ workspace: z.string(), status: z.enum(["draft", "scheduled", "sending", "sent", "cancelled"]).optional(), limit: z.number().int().max(100).optional() }),
+        response: z.object({ broadcasts: z.array(z.object({ id: z.string(), subject: z.string(), status: z.string(), sent_at: z.number().nullable(), audience_tag: z.string().nullable() })) }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "read",
+    }),
+    "broadcast:get": receiver({
+        receiver: "broadcast:get",
+        summary: "Get a single broadcast with recipient counts",
+        request: z.object({ workspace: z.string(), broadcastId: z.string() }),
+        response: z.object({ broadcast: z.record(z.string(), z.unknown()) }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "read",
+    }),
+    "broadcast:test": receiver({
+        receiver: "broadcast:test",
+        summary: "Send a test email for a broadcast to one address",
+        request: z.object({ workspace: z.string(), broadcastId: z.string(), to: z.string().email() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "signal", cost: "variable", reversible: false, idempotent: false, auth: "write",
+    }),
+    "broadcast:send": receiver({
+        receiver: "broadcast:send",
+        summary: "Seed recipients from audience tag, apply suppression, enqueue the send batch",
+        request: z.object({ workspace: z.string(), broadcastId: z.string() }),
+        response: z.object({ enqueued: z.number() }),
+        effect: "signal", cost: "variable", reversible: false, idempotent: false, auth: "write",
+    }),
+    "broadcast:schedule": receiver({
+        receiver: "broadcast:schedule",
+        summary: "Schedule a broadcast to send at a future unix timestamp",
+        request: z.object({ workspace: z.string(), broadcastId: z.string(), scheduled_at: z.number().int() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "write",
+    }),
+    "broadcast:cancel": receiver({
+        receiver: "broadcast:cancel",
+        summary: "Cancel a scheduled or in-progress broadcast",
+        request: z.object({ workspace: z.string(), broadcastId: z.string() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "write",
+    }),
+    // ── Audience (public subscribe/unsubscribe) ────────────────────────────────
+    "audience:subscribe": receiver({
+        receiver: "audience:subscribe",
+        summary: "Begin double opt-in for a contact — writes consent:email:pending tag, sends confirm email",
+        request: z.object({ workspace: z.string(), address: z.string().email(), list: z.string().optional(), ref: z.string().optional() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "public",
+    }),
+    "audience:unsubscribe": receiver({
+        receiver: "audience:unsubscribe",
+        summary: "One-click unsubscribe — writes suppression row and flips consent tag; RFC 8058 safe",
+        request: z.object({ workspace: z.string(), channel: z.enum(["email", "sms", "whatsapp"]).optional(), address: z.string(), token: z.string() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "public",
+    }),
+    "audience:confirm": receiver({
+        receiver: "audience:confirm",
+        summary: "Confirm email subscription via opt-in token — flips consent tag to subscribed",
+        request: z.object({ token: z.string() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "public",
+    }),
+    // ── Winback batch ─────────────────────────────────────────────────────────
+    "audience:winback": receiver({
+        receiver: "audience:winback",
+        summary: "Re-engage dormant subscribers (batch winback sequence tool) — queries contacts with no send in `days` days, sends one re-engage email each through the suppression-checked send path",
+        request: z.object({ days: z.number().optional(), campaign: z.string().optional() }),
+        response: z.object({ ok: z.boolean(), sent: z.number(), scanned: z.number() }),
+        effect: "signal", cost: "variable", reversible: false, idempotent: false, auth: "write",
+    }),
+    // ── Workflow tool — channel-neutral send ──────────────────────────────────
+    "message:send": receiver({
+        receiver: "message:send",
+        summary: "Send a message to one address via channel — suppression-checked; sms/whatsapp dissolve until adapters ship",
+        request: z.object({ workspace: z.string(), channel: z.enum(["email", "sms", "whatsapp"]), to: z.string(), subject: z.string().optional(), body: z.string(), campaign: z.string().optional() }),
+        response: z.object({ ok: z.boolean() }),
+        effect: "signal", cost: "variable", reversible: false, idempotent: false, auth: "write",
+    }),
+};
+/**
+ * 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 `text/agent-first-spec-plan.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"],
+    /** SOP: define a workflow → shape it with a diff → run it. */
+    sop: ["workflow:create", "workflow:apply-diff", "workflow:run"],
+};
+//# sourceMappingURL=receivers.js.map