@oneie/sdk 0.13.9 → 0.14.1

package/dist/receivers.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { AgentActionResponseSchema, AgentStatusResponseSchema, CapabilityItemSchema, PayResponseSchema, RegisterResponseSchema, StatsSchema, StepKind, WorkflowDiffSchema, } from "./schemas.js";
 import { FieldSchema, ResourceTypeSchema } from "./types.js";
+import { GroupEntitySchema } from "./generated/schemas/index.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.
@@ -26,6 +27,42 @@ export const RECEIVERS = {
         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,
     }),
+    "agent:own-link": receiver({
+        receiver: "agent:own-link",
+        summary: "Generate a signed ownership invitation link for a registered agent; optionally deliver it as a native button on Telegram or Discord",
+        request: z.object({
+            agent_id: z.string().describe("The agent's actor ID (aid from world_actors / actorId from auth.md registration)"),
+            channel_group: z.string().optional().describe("Optional delivery channel: tg-<chat_id> / dc-<channel_id> / web-<group>"),
+            workspace: z.string().optional().describe("Workspace slug for credential lookup when channel_group is set"),
+        }),
+        response: z.object({
+            ok: z.literal(true),
+            adopt_url: z.string(),
+            expires_in: z.number(),
+            agent_id: z.string(),
+            delivered: z.boolean().optional(),
+        }),
+        effect: "ask", auth: "owner", reversible: false, idempotent: false,
+    }),
+    "agent:provision": receiver({
+        receiver: "agent:provision",
+        summary: "Zero-to-live in one unauthenticated call — register + workspace + publish agent + import skills + invite owner",
+        request: z.object({
+            name: z.string().optional(),
+            agentName: z.string().optional(),
+            content: z.string().optional(),
+            skills: z.array(z.string()).optional(),
+            invite: z.object({ email: z.string().email().optional(), role: z.string().optional() }).optional(),
+            live: z.boolean().optional(),
+        }),
+        response: z.object({
+            uid: z.string(),
+            workspace: z.string(),
+            apiKey: z.string(),
+            inviteUrl: z.string().optional(),
+        }),
+        effect: "ask", auth: "none", reversible: false, idempotent: false,
+    }),
     "agent:bootstrap": receiver({
         receiver: "agent:bootstrap",
         summary: "Atomically provision a workspace + actor + scoped key; optionally invite an initial human owner",
@@ -168,7 +205,12 @@ export const RECEIVERS = {
     "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() }),
+        request: z.object({
+            name: z.string(),
+            // "group" is the D1 group_type for campaigns/collections; absent from the TypeDB enum
+            type: GroupEntitySchema.shape["group-type"].or(z.literal("group")),
+            tags: z.array(z.string()).optional(),
+        }),
         response: z.object({ gid: z.string() }), effect: "ask", auth: "manage_groups",
     }),
     "world:update-group": receiver({
@@ -309,6 +351,30 @@ export const RECEIVERS = {
         request: z.object({ group: z.string().optional(), key: z.string(), fields: z.array(FieldSchema), label: z.string().optional() }),
         response: ok, effect: "ask", auth: "manage_things",
     }),
+    "lifecycle:save": receiver({
+        receiver: "lifecycle:save",
+        summary: "Save a lifecycle definition to a workspace (operator push from data/lifecycles/*.toml via `one push`)",
+        request: z.object({ slug: z.string(), lifecycle: z.string(), def: z.record(z.string(), z.unknown()) }),
+        response: z.object({ ok: z.literal(true), id: z.string() }),
+        effect: "ask", auth: "manage_lifecycle", reversible: false,
+        examples: [{ slug: "acme", lifecycle: "marketing", def: { id: "marketing", name: "Marketing Funnel", version: 1, stages: [], transitions: [], arcs: [], monotonic: true } }],
+    }),
+    "tools:connect": receiver({
+        receiver: "tools:connect",
+        summary: "Connect a Composio API-KEY toolkit to a workspace headlessly (OAuth stays in the browser flow)",
+        request: z.object({ slug: z.string(), toolkit: z.string(), credentials: z.record(z.string(), z.string()).optional(), authScheme: z.string().optional() }),
+        response: z.object({ ok: z.literal(true), connectionId: z.string().optional(), authUrl: z.string().optional() }),
+        effect: "ask", auth: "manage_integrations", reversible: false,
+        examples: [{ slug: "acme", toolkit: "stripe", credentials: { api_key: "sk_test_..." } }],
+    }),
+    "brand:set": receiver({
+        receiver: "brand:set",
+        summary: "Write up to 6 brand color tokens (primary/secondary/accent/bg/text/border) to a workspace theme",
+        request: z.object({ slug: z.string(), tokens: z.object({ primary: z.string().optional(), secondary: z.string().optional(), accent: z.string().optional(), bg: z.string().optional(), text: z.string().optional(), border: z.string().optional() }) }),
+        response: z.object({ ok: z.literal(true), theme: z.record(z.string(), z.unknown()) }),
+        effect: "ask", auth: "manage_workspace", reversible: true,
+        examples: [{ slug: "acme", tokens: { primary: "hsl(216 55% 25%)", secondary: "hsl(160 40% 45%)" } }],
+    }),
     "world:create-thing": receiver({
         receiver: "world:create-thing",
         summary: "Create a thing (skill, token, product) in the world",
@@ -385,6 +451,33 @@ export const RECEIVERS = {
         response: z.object({ outcome: z.literal("granted"), id: z.string(), grantee: z.string(), scope: z.string() }),
         effect: "ask", auth: "mint_capability", reversible: false,
     }),
+    // ── model router (C3/C4 — do-metabolism) ──
+    "world:pick-model": receiver({
+        receiver: "world:pick-model",
+        summary: "Return the best proven model for a task shape (warmed/cold/toxic-escalate/fallback-unreachable)",
+        request: z.object({ shape: z.string().min(1) }),
+        response: z.object({
+            ok: z.boolean(),
+            model: z.string().optional(),
+            effort: z.string().optional(),
+            reason: z.enum(['warmed', 'cold', 'toxic-escalate', 'fallback-unreachable']).optional(),
+        }),
+        effect: "ask", auth: "none", reversible: true,
+    }),
+    "world:seed-router": receiver({
+        receiver: "world:seed-router",
+        summary: "Seed initial shape→model capability rows (platform-gated, idempotent)",
+        request: z.object({ shapes: z.array(z.string()).optional() }),
+        response: z.object({ ok: z.boolean(), seeded: z.number().optional() }),
+        effect: "ask", auth: "platform", reversible: true,
+    }),
+    "attention:follow": receiver({
+        receiver: "attention:follow",
+        summary: "Subscribe to a do-event axis; writes ws-scoped mark so fan-out stays tenant-isolated",
+        request: z.object({ axis: z.string().min(1) }),
+        response: z.object({ ok: z.boolean(), target: z.string().optional() }),
+        effect: "ask", auth: "session", reversible: true,
+    }),
     // ════════════════════════════════════════════════════════════════════════
     // C4 — remaining families (sequenced by recipe: identity → groups → BUILD
     // → TRADE → TRANSACT → reads). Request schemas mirror the exact client.ts
@@ -468,6 +561,41 @@ export const RECEIVERS = {
         response: ok,
         effect: "signal", idempotent: true,
     }),
+    "world:announce": receiver({
+        receiver: "world:announce",
+        summary: "Broadcast a tagged signal; the world fans it to every subscriber whose follow-tags intersect",
+        request: z.object({
+            tags: z.array(z.string()),
+            content: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), matched: z.number().optional(), actors: z.array(z.string()).optional() }),
+        effect: "ask",
+    }),
+    "tasks:announce": receiver({
+        receiver: "tasks:announce",
+        summary: "Announce a task into the world by its tags — the first caller of world:announce",
+        request: z.object({
+            taskId: z.string(),
+            tags: z.array(z.string()),
+        }),
+        response: z.object({ ok: z.boolean(), taskId: z.string().optional(), matched: z.number().optional(), actors: z.array(z.string()).optional() }),
+        effect: "ask",
+    }),
+    "tasks:mine": receiver({
+        receiver: "tasks:mine",
+        summary: "My work queue: the open tasks whose words match what I subscribed to, ranked by learned weight (context-strength), not static priority",
+        request: z.object({ limit: z.number().optional() }),
+        response: z.object({
+            ok: z.boolean(),
+            tasks: z.array(z.object({
+                id: z.string(),
+                name: z.string(),
+                tags: z.array(z.string()),
+                weight: z.number(),
+            })),
+        }),
+        effect: "ask", idempotent: true,
+    }),
     // ── agents (TRADE / lifecycle) ──
     "agents:register": receiver({
         receiver: "agents:register",
@@ -519,6 +647,22 @@ export const RECEIVERS = {
         response: PayResponseSchema,
         effect: "ask", cost: "variable", settles: "onchain", reversible: false, simulatable: true,
     }),
+    "tasks:stake": receiver({
+        receiver: "tasks:stake",
+        summary: "Stake SUI against a task on-chain to raise its priority weight. 0.1 SUI = +1 weight unit. Irreversible — conviction signal, not a deposit.",
+        request: z.object({
+            taskObjectId: z.string().regex(/^0x[a-fA-F0-9]{64}$/, "Sui object ID"),
+            units: z.number().int().positive().default(1),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            digest: z.string().optional(),
+            weightBefore: z.number().optional(),
+            weightAfter: z.number().optional(),
+            suiSpent: z.number().optional(),
+        }),
+        effect: "ask", cost: "variable", settles: "onchain", reversible: false, simulatable: false,
+    }),
     // ── market (A2A negotiation, C2) ──
     "market:offer": receiver({
         receiver: "market:offer",
@@ -694,7 +838,7 @@ export const RECEIVERS = {
         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(),
+            mode: z.string().optional(), visibility: z.string().optional(), scope: z.string().optional(), entitlement: z.string().optional(),
             tags: z.array(z.string()).optional(),
             rubricThresholds: z.object({
                 fit: z.number().optional(), form: z.number().optional(),
@@ -784,6 +928,22 @@ export const RECEIVERS = {
         }),
         effect: "ask", cost: "free", idempotent: true,
     }),
+    "meta:reputation": receiver({
+        receiver: "meta:reputation",
+        summary: "Read an actor's reputation score — weighted commend/flag balance from claw_paths + vote counts from reputation_votes",
+        request: z.object({ uid: z.string().describe("The actor's slug or aid to look up") }),
+        response: z.object({
+            uid: z.string(),
+            score: z.number().describe("Normalised 0–1 float: strength / (strength + resistance)"),
+            commend_count: z.number(),
+            flag_count: z.number(),
+            strength: z.number(),
+            resistance: z.number(),
+            why: z.array(z.string()).describe("Plain-English summary of the score"),
+            howToRaise: z.array(z.string()).describe("Actionable hints for improving score"),
+        }),
+        effect: "ask", cost: "free", idempotent: true,
+    }),
     "meta:types": receiver({
         receiver: "meta:types",
         summary: "Read the resource-type manifest for the caller's workspace, plus the built-in industry templates",
@@ -1129,6 +1289,61 @@ export const RECEIVERS = {
         }),
         effect: "ask", cost: "free", reversible: true, idempotent: false, auth: "member",
     }),
+    // ── FUNNELS (text/funnels-plan.md) — author + run funnel definitions ──────────
+    // funnel:create — create a new funnel definition (draft).
+    "funnel:create": receiver({
+        receiver: "funnel:create",
+        summary: "Create a new funnel definition in a workspace (draft status); slug unique per workspace",
+        request: z.object({
+            workspaceSlug: z.string(),
+            slug: z.string(),
+            name: z.string(),
+            playbookNode: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), id: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: false, auth: "admin",
+    }),
+    // funnel:update-step — replace the steps + edges graph of a funnel (bumps version).
+    "funnel:update-step": receiver({
+        receiver: "funnel:update-step",
+        summary: "Replace a funnel's steps + edges graph; returns the new version (idempotent on identical payload)",
+        request: z.object({
+            workspaceSlug: z.string(),
+            funnelId: z.string(),
+            steps: z.array(z.unknown()),
+            edges: z.array(z.unknown()),
+        }),
+        response: z.object({ ok: z.boolean(), version: z.number().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "admin",
+    }),
+    // funnel:publish — flip a funnel from draft to published.
+    "funnel:publish": receiver({
+        receiver: "funnel:publish",
+        summary: "Publish a funnel (status draft → published); idempotent if already published",
+        request: z.object({ workspaceSlug: z.string(), funnelId: z.string() }),
+        response: z.object({ ok: z.boolean(), status: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "admin",
+    }),
+    // funnel:advance — move a visitor's session cursor; may move the visitor's lifecycle stage
+    // (delegates to entity:tag — the sole stage_transition writer). Public: anonymous visitors fire this.
+    "funnel:advance": receiver({
+        receiver: "funnel:advance",
+        summary: "Advance a visitor through a funnel step; returns next step + any lifecycle stage moved via entity:tag",
+        request: z.object({
+            workspaceSlug: z.string(),
+            funnelSlug: z.string(),
+            stepSlug: z.string(),
+            visitorHash: z.string(),
+            formData: z.record(z.string(), z.unknown()).optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            nextStepSlug: z.string().optional(),
+            lifecycleStage: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "signal", cost: "free", reversible: false, idempotent: false, auth: "public",
+    }),
     // entity:meta — editable profile fields for an entity (website, industry, location, …).
     "entity:meta": receiver({
         receiver: "entity:meta",
@@ -1215,6 +1430,13 @@ export const RECEIVERS = {
         response: z.object({ products: z.array(z.record(z.string(), z.unknown())).optional(), error: z.string().optional() }),
         effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "public",
     }),
+    "products:get": receiver({
+        receiver: "products:get",
+        summary: "Get one storefront product with its prices (public, active-only) — the single-record read a data-bound page block resolves through",
+        request: z.object({ slug: z.string(), pid: z.string() }),
+        response: z.object({ product: z.record(z.string(), z.unknown()).nullable().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "public",
+    }),
     "products:archive": receiver({
         receiver: "products:archive",
         summary: "Archive a product (reversible via products:update)",
@@ -1240,14 +1462,14 @@ export const RECEIVERS = {
     "pages:create": receiver({
         receiver: "pages:create",
         summary: "Create a workspace page (draft) from a title + sections",
-        request: z.object({ slug: z.string(), title: z.string(), sections: z.record(z.string(), z.unknown()), pageSlug: z.string().optional() }),
+        request: z.object({ slug: z.string(), title: z.string(), sections: z.array(z.object({ component: z.string(), props: z.record(z.string(), z.unknown()) })), pageSlug: z.string().optional() }),
         response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), url: z.string().optional(), status: z.string().optional(), error: z.string().optional() }),
         effect: "ask", cost: "free", reversible: true, idempotent: false, auth: "member",
     }),
     "pages:edit": receiver({
         receiver: "pages:edit",
         summary: "Edit a workspace page's title or sections",
-        request: z.object({ slug: z.string(), page: z.string(), title: z.string().optional(), sections: z.record(z.string(), z.unknown()).optional() }),
+        request: z.object({ slug: z.string(), page: z.string(), title: z.string().optional(), sections: z.array(z.object({ component: z.string(), props: z.record(z.string(), z.unknown()) })).optional() }),
         response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), url: z.string().optional(), status: z.string().optional(), error: z.string().optional() }),
         effect: "ask", cost: "free", reversible: true, idempotent: false, auth: "member",
     }),
@@ -1265,6 +1487,20 @@ export const RECEIVERS = {
         response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), url: z.string().optional(), status: z.string().optional(), error: z.string().optional() }),
         effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "member",
     }),
+    "pages:versions": receiver({
+        receiver: "pages:versions",
+        summary: "List a page's saved version snapshots, newest first",
+        request: z.object({ slug: z.string(), page: z.string() }),
+        response: z.object({ ok: z.boolean(), slug: z.string().optional(), versions: z.array(z.object({ ts: z.number(), bytes: z.number(), key: z.string() })).optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "member",
+    }),
+    "pages:restore": receiver({
+        receiver: "pages:restore",
+        summary: "Restore a page to a prior version snapshot (snapshots current state first)",
+        request: z.object({ slug: z.string(), page: z.string(), ts: z.number() }),
+        response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), url: z.string().optional(), status: z.string().optional(), restoredTs: z.number().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: false, auth: "member",
+    }),
     "settings:write": receiver({
         receiver: "settings:write",
         summary: "Write a workspace setting value (caller or authorized descendant)",
@@ -1624,6 +1860,27 @@ export const RECEIVERS = {
         auth: "manage_workflows",
         examples: [{ workflowId: "wf_abc" }],
     }),
+    "build:run": receiver({
+        receiver: "build:run",
+        summary: "Start a build cycle — gates on credits (funding-of), spawns the BuildRun DO, runs the stub W1 wave, returns a runId",
+        request: z.object({
+            goal: z.string(),
+            mode: z.enum(["local", "remote"]).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: [{ goal: "add a health endpoint", mode: "local" }],
+    }),
+    "build:resume": receiver({
+        receiver: "build:resume",
+        summary: "Advance a parked build run by one wave — re-validates the run against the caller's workspace",
+        request: z.object({ runId: z.string() }),
+        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" }],
+    }),
     "human:resolve": receiver({
         receiver: "human:resolve",
         summary: "Resolve a suspended human step — carries { runId, stepId, decision | formPayload } to the run DO",
@@ -1737,7 +1994,7 @@ export const RECEIVERS = {
         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() })),
+            skills: z.array(z.object({ name: z.string(), size: z.number(), sealed: z.boolean().optional() })),
         }),
         effect: "ask", cost: "free", idempotent: true, simulatable: false, auth: "view_workflows",
         examples: [{}],
@@ -2134,6 +2391,114 @@ export const RECEIVERS = {
         response: z.object({ ok: z.boolean() }),
         effect: "signal", cost: "variable", reversible: false, idempotent: false, auth: "write",
     }),
+    // ── Send Link — actor-bound tracked URL (CRM personalisation) ──────────────
+    "links:create": receiver({
+        receiver: "links:create",
+        summary: "Create an actor-bound tracked link. On click `/go/:id` elevates the contact to rung-4 identity, pre-warms their snapshot, and personalises the page + chat. Creation is gated: the caller must hold authority over the target contact's workspace; `createdBy` is stamped from the attested session, never the body.",
+        request: z.object({
+            actorId: z.string().describe("Contact (actor) the link is bound to — must belong to the caller's workspace or a descendant"),
+            destination: z.string().optional().describe("Path the click lands on (must start with '/'); default '/'"),
+            context: z.string().optional().describe("Extra context injected into the agent's system prompt for this session"),
+            greeting: z.string().optional().describe("Override the chat agent's opening line"),
+            campaignId: z.string().optional().describe("Group clicks under a campaign for the learning loop"),
+            expiresInDays: z.number().optional().describe("Link TTL in days; omitted = never expires"),
+        }),
+        response: z.object({ id: z.string(), sig: z.string(), url: z.string() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: false, auth: "member",
+        examples: [{ actorId: "u-123", destination: "/pricing", expiresInDays: 90 }],
+    }),
+    "links:bulk-create": receiver({
+        receiver: "links:bulk-create",
+        summary: "Create one actor-bound tracked link per contact for a selected segment (the segment-campaign send). Authority is walked PER contact — any the caller can't reach is skipped (counted in `denied`), never failing the batch. Capped at 200.",
+        request: z.object({
+            actorIds: z.array(z.string()).min(1).max(200).describe("Contacts to mint a link for — each must belong to the caller's workspace or a descendant"),
+            destination: z.string().optional().describe("Shared destination path (must start with '/'); default '/'"),
+            campaignId: z.string().optional().describe("Group all clicks under one campaign for the learning loop"),
+            expiresInDays: z.number().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            created: z.number().optional(),
+            denied: z.number().optional(),
+            links: z.array(z.object({ actorId: z.string(), url: z.string() })).optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", reversible: false, idempotent: false, auth: "member",
+        examples: [{ actorIds: ["u-1", "u-2"], destination: "/launch", campaignId: "q3" }],
+    }),
+    // ── fn: family — typed substrate function calls (C5) ──────────────────────
+    "fn:run": receiver({
+        receiver: "fn:run",
+        summary: "Execute an allowlisted TypeDB function by name. Returns the function's result rows. Not public — caller must be authenticated; the resolver re-walks authority before executing.",
+        request: z.object({
+            fn: z.string().describe("Function name from FN_MAP (e.g. 'optimal_route', 'actionable_hypotheses')"),
+            args: z.record(z.string(), z.unknown()).optional().describe("Named arguments matching the function's param list"),
+            workspace: z.string().optional().describe("Workspace slug for authority context"),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            fn: z.string(),
+            rows: z.array(z.record(z.string(), z.unknown())),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: true, auth: "member",
+        examples: [{ fn: "optimal_route", args: { $from: "actor-123", $skill: "writing" }, workspace: "acme" }],
+    }),
+    // ── rag: family — OO-Brain hybrid vector+BM25 search ──────────────────────
+    "rag:search": receiver({
+        receiver: "rag:search",
+        summary: "Search the OO-Brain knowledge corpus (Supabase pgvector). Hybrid retrieval: vector cosine + tsvector BM25 fused with RRF. Returns top-k chunks + a query_id. Always follow with rag:mark to close the quality loop.",
+        request: z.object({
+            query: z.string().describe("Natural-language query. Full sentence beats keywords."),
+            k: z.number().int().min(1).max(20).optional().default(5).describe("Chunks to return (1–20, default 5)."),
+            corpus: z.string().optional().default("@oo-brain").describe("Which imported brain (@-pointer, e.g. '@oo-brain'). Authority-walked against your workspace; omit for the platform default."),
+            vault: z.enum(["oo-brain", "agency-operator", "personal-brain", "all"]).optional().default("all"),
+            filter_path_prefix: z.string().optional(),
+            filter_tags: z.array(z.string()).optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            query_id: z.string().nullable().describe("UUID to pass to rag:mark. Null when no chunks matched."),
+            chunks: z.array(z.object({
+                id: z.string().optional(),
+                vault_name: z.string(),
+                file_path: z.string(),
+                chunk_content: z.string(),
+                contextual_blurb: z.string().optional(),
+                rrf_score: z.number().optional(),
+                frontmatter: z.record(z.string(), z.unknown()).optional(),
+            })),
+            query: z.string(),
+            vault: z.string(),
+        }),
+        effect: "ask", auth: "read_corpus", cost: { fixed: 1 }, reversible: false, idempotent: true,
+    }),
+    "rag:list": receiver({
+        receiver: "rag:list",
+        summary: "List the knowledge corpora you may search (@-pointers), resolved by the workspace authority walk. The platform corpus @oo-brain is always included.",
+        request: z.object({}),
+        response: z.object({
+            ok: z.boolean(),
+            corpora: z.array(z.string()).describe("@-pointers the caller may read, e.g. ['@oo-brain']."),
+        }),
+        effect: "ask", auth: "read_corpus", cost: "free", reversible: false, idempotent: true,
+    }),
+    "rag:mark": receiver({
+        receiver: "rag:mark",
+        summary: "Close the quality loop on a rag:search call. Call before the turn ends. 'mark' = chunks helped; 'warn' = chunks didn't help; 'unsure' = can't assess.",
+        request: z.object({
+            query_id: z.string().uuid(),
+            outcome: z.enum(["mark", "warn", "unsure"]),
+            notes: z.string().optional(),
+            corpus: z.string().optional().default("@oo-brain").describe("The corpus the query_id belongs to (@-pointer). Authority-walked; omit for the platform default."),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            query_id: z.string(),
+            outcome: z.string(),
+        }),
+        effect: "signal", auth: "read_corpus", cost: "free", reversible: false, idempotent: false,
+    }),
 };
 /**
  * RECIPES — the four agent journeys as typed, ordered receiver sequences (C6).
@@ -2152,5 +2517,7 @@ export const RECIPES = {
     transact: ["market:bounty", "pay:weight"],
     /** SOP: define a workflow → shape it with a diff → run it. */
     sop: ["workflow:create", "workflow:apply-diff", "workflow:run"],
+    /** A2A: negotiate a deal → escrow → deliver → verify → settle (or dispute + refund). */
+    a2a: ["market:offer", "market:counter", "market:accept", "market:escrow", "market:deliver", "market:verify", "market:settle", "market:dispute"],
 };
 //# sourceMappingURL=receivers.js.map