@oneie/sdk 0.10.0 → 0.11.0

package/dist/receivers.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { AgentActionResponseSchema, AgentStatusResponseSchema, CapabilityItemSchema, PayResponseSchema, RegisterResponseSchema, StatsSchema, } from "./schemas.js";
+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.
@@ -18,6 +18,13 @@ const ok = z.object({ ok: z.boolean() });
  */
 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",
@@ -150,6 +157,50 @@ export const RECEIVERS = {
         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",
@@ -157,15 +208,38 @@ export const RECEIVERS = {
     }),
     "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,
+        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: "manage_keys", reversible: false,
+        request: z.object({ keyId: z.string() }), response: ok, effect: "ask", auth: "member", scope: "write", reversible: false,
     }),
     "world:create-thing": receiver({
         receiver: "world:create-thing",
@@ -243,13 +317,7 @@ export const RECEIVERS = {
         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-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",
@@ -257,29 +325,9 @@ export const RECEIVERS = {
         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",
-    }),
+    // 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",
@@ -325,18 +373,7 @@ export const RECEIVERS = {
         }),
         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",
-    }),
+    // paths:bridge killed (C7): no resolver, no route, no caller
     // ── subscriptions ──
     "subscriptions:register": receiver({
         receiver: "subscriptions:register",
@@ -391,16 +428,7 @@ export const RECEIVERS = {
         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,
-    }),
+    // agents:deploy-on-behalf killed (C7): no resolver, no route, no caller
     // ── pay (TRANSACT — onchain settlement) ──
     "pay:weight": receiver({
         receiver: "pay:weight",
@@ -409,6 +437,115 @@ export const RECEIVERS = {
         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",
@@ -452,6 +589,16 @@ export const RECEIVERS = {
         })),
         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",
@@ -475,22 +622,7 @@ export const RECEIVERS = {
         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",
-    }),
+    // loop:close killed (C7): no resolver, no route, no caller
     // ── reads (free · idempotent) ──
     "signals:list": receiver({
         receiver: "signals:list",
@@ -606,12 +738,693 @@ export const RECEIVERS = {
         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 `plans/agent-first-spec.md`.
+ * 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. */
@@ -622,5 +1435,7 @@ export const RECIPES = {
     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